Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/common/autoconf/generated-configure.sh
+++ new/common/autoconf/generated-configure.sh
1 1 #!/bin/bash
2 2 #
3 3 # ##########################################################
4 4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
5 5 # ##########################################################
6 6 #
7 7 #! /bin/sh
8 8 # Guess values for system-dependent variables and create Makefiles.
9 9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
10 10 #
11 11 # Report bugs to <build-dev@openjdk.java.net>.
12 12 #
13 13 #
14 14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
15 15 #
16 16 #
17 17 # This configure script is free software; the Free Software Foundation
18 18 # gives unlimited permission to copy, distribute and modify it.
19 19 ## -------------------- ##
20 20 ## M4sh Initialization. ##
21 21 ## -------------------- ##
22 22
23 23 # Be more Bourne compatible
24 24 DUALCASE=1; export DUALCASE # for MKS sh
25 25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
26 26 emulate sh
27 27 NULLCMD=:
28 28 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
29 29 # is contrary to our usage. Disable this feature.
30 30 alias -g '${1+"$@"}'='"$@"'
31 31 setopt NO_GLOB_SUBST
32 32 else
33 33 case `(set -o) 2>/dev/null` in #(
34 34 *posix*) :
35 35 set -o posix ;; #(
36 36 *) :
37 37 ;;
38 38 esac
39 39 fi
40 40
41 41
42 42 as_nl='
43 43 '
44 44 export as_nl
45 45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
46 46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
47 47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
48 48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
49 49 # Prefer a ksh shell builtin over an external printf program on Solaris,
50 50 # but without wasting forks for bash or zsh.
51 51 if test -z "$BASH_VERSION$ZSH_VERSION" \
52 52 && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
53 53 as_echo='print -r --'
54 54 as_echo_n='print -rn --'
55 55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
56 56 as_echo='printf %s\n'
57 57 as_echo_n='printf %s'
58 58 else
59 59 if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
60 60 as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
61 61 as_echo_n='/usr/ucb/echo -n'
62 62 else
63 63 as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
64 64 as_echo_n_body='eval
65 65 arg=$1;
66 66 case $arg in #(
67 67 *"$as_nl"*)
68 68 expr "X$arg" : "X\\(.*\\)$as_nl";
69 69 arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
70 70 esac;
71 71 expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
72 72 '
73 73 export as_echo_n_body
74 74 as_echo_n='sh -c $as_echo_n_body as_echo'
75 75 fi
76 76 export as_echo_body
77 77 as_echo='sh -c $as_echo_body as_echo'
78 78 fi
79 79
80 80 # The user is always right.
81 81 if test "${PATH_SEPARATOR+set}" != set; then
82 82 PATH_SEPARATOR=:
83 83 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
84 84 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
85 85 PATH_SEPARATOR=';'
86 86 }
87 87 fi
88 88
89 89
90 90 # IFS
91 91 # We need space, tab and new line, in precisely that order. Quoting is
92 92 # there to prevent editors from complaining about space-tab.
93 93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
94 94 # splitting by setting IFS to empty value.)
95 95 IFS=" "" $as_nl"
96 96
97 97 # Find who we are. Look in the path if we contain no directory separator.
98 98 as_myself=
99 99 case $0 in #((
100 100 *[\\/]* ) as_myself=$0 ;;
101 101 *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
102 102 for as_dir in $PATH
103 103 do
104 104 IFS=$as_save_IFS
105 105 test -z "$as_dir" && as_dir=.
106 106 test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
107 107 done
108 108 IFS=$as_save_IFS
109 109
110 110 ;;
111 111 esac
112 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
113 113 # in which case we are not to be found in the path.
114 114 if test "x$as_myself" = x; then
115 115 as_myself=$0
116 116 fi
117 117 if test ! -f "$as_myself"; then
118 118 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
119 119 exit 1
120 120 fi
121 121
122 122 # Unset variables that we do not need and which cause bugs (e.g. in
123 123 # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
124 124 # suppresses any "Segmentation fault" message there. '((' could
125 125 # trigger a bug in pdksh 5.2.14.
126 126 for as_var in BASH_ENV ENV MAIL MAILPATH
127 127 do eval test x\${$as_var+set} = xset \
128 128 && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
129 129 done
130 130 PS1='$ '
131 131 PS2='> '
132 132 PS4='+ '
133 133
134 134 # NLS nuisances.
135 135 LC_ALL=C
136 136 export LC_ALL
137 137 LANGUAGE=C
138 138 export LANGUAGE
139 139
140 140 # CDPATH.
141 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
142 142
143 143 # Use a proper internal environment variable to ensure we don't fall
144 144 # into an infinite loop, continuously re-executing ourselves.
145 145 if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
146 146 _as_can_reexec=no; export _as_can_reexec;
147 147 # We cannot yet assume a decent shell, so we have to provide a
148 148 # neutralization value for shells without unset; and this also
149 149 # works around shells that cannot unset nonexistent variables.
150 150 # Preserve -v and -x to the replacement shell.
151 151 BASH_ENV=/dev/null
152 152 ENV=/dev/null
153 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
154 154 case $- in # ((((
155 155 *v*x* | *x*v* ) as_opts=-vx ;;
156 156 *v* ) as_opts=-v ;;
157 157 *x* ) as_opts=-x ;;
158 158 * ) as_opts= ;;
159 159 esac
160 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
161 161 # Admittedly, this is quite paranoid, since all the known shells bail
162 162 # out after a failed `exec'.
163 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
164 164 as_fn_exit 255
165 165 fi
166 166 # We don't want this to propagate to other subprocesses.
167 167 { _as_can_reexec=; unset _as_can_reexec;}
168 168 if test "x$CONFIG_SHELL" = x; then
169 169 as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
170 170 emulate sh
171 171 NULLCMD=:
172 172 # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
173 173 # is contrary to our usage. Disable this feature.
174 174 alias -g '\${1+\"\$@\"}'='\"\$@\"'
175 175 setopt NO_GLOB_SUBST
176 176 else
177 177 case \`(set -o) 2>/dev/null\` in #(
178 178 *posix*) :
179 179 set -o posix ;; #(
180 180 *) :
181 181 ;;
182 182 esac
183 183 fi
184 184 "
185 185 as_required="as_fn_return () { (exit \$1); }
186 186 as_fn_success () { as_fn_return 0; }
187 187 as_fn_failure () { as_fn_return 1; }
188 188 as_fn_ret_success () { return 0; }
189 189 as_fn_ret_failure () { return 1; }
190 190
191 191 exitcode=0
192 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
193 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
194 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
195 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
196 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
197 197
198 198 else
199 199 exitcode=1; echo positional parameters were not saved.
200 200 fi
201 201 test x\$exitcode = x0 || exit 1
202 202 test -x / || exit 1"
203 203 as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
204 204 as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
205 205 eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
206 206 test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
207 207 test \$(( 1 + 1 )) = 2 || exit 1"
208 208 if (eval "$as_required") 2>/dev/null; then :
209 209 as_have_required=yes
210 210 else
211 211 as_have_required=no
212 212 fi
213 213 if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
214 214
215 215 else
216 216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
217 217 as_found=false
218 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
219 219 do
220 220 IFS=$as_save_IFS
221 221 test -z "$as_dir" && as_dir=.
222 222 as_found=:
223 223 case $as_dir in #(
224 224 /*)
225 225 for as_base in sh bash ksh sh5; do
226 226 # Try only shells that exist, to save several forks.
227 227 as_shell=$as_dir/$as_base
228 228 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
229 229 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
230 230 CONFIG_SHELL=$as_shell as_have_required=yes
231 231 if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
232 232 break 2
233 233 fi
234 234 fi
235 235 done;;
236 236 esac
237 237 as_found=false
238 238 done
239 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
240 240 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
241 241 CONFIG_SHELL=$SHELL as_have_required=yes
242 242 fi; }
243 243 IFS=$as_save_IFS
244 244
245 245
246 246 if test "x$CONFIG_SHELL" != x; then :
247 247 export CONFIG_SHELL
248 248 # We cannot yet assume a decent shell, so we have to provide a
249 249 # neutralization value for shells without unset; and this also
250 250 # works around shells that cannot unset nonexistent variables.
251 251 # Preserve -v and -x to the replacement shell.
252 252 BASH_ENV=/dev/null
253 253 ENV=/dev/null
254 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
255 255 case $- in # ((((
256 256 *v*x* | *x*v* ) as_opts=-vx ;;
257 257 *v* ) as_opts=-v ;;
258 258 *x* ) as_opts=-x ;;
259 259 * ) as_opts= ;;
260 260 esac
261 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
262 262 # Admittedly, this is quite paranoid, since all the known shells bail
263 263 # out after a failed `exec'.
264 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
265 265 exit 255
266 266 fi
267 267
268 268 if test x$as_have_required = xno; then :
269 269 $as_echo "$0: This script requires a shell more modern than all"
270 270 $as_echo "$0: the shells that I found on your system."
271 271 if test x${ZSH_VERSION+set} = xset ; then
272 272 $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
273 273 $as_echo "$0: be upgraded to zsh 4.3.4 or later."
274 274 else
275 275 $as_echo "$0: Please tell bug-autoconf@gnu.org and
276 276 $0: build-dev@openjdk.java.net about your system, including
277 277 $0: any error possibly output before this message. Then
278 278 $0: install a modern shell, or manually run the script
279 279 $0: under such a shell if you do have one."
280 280 fi
281 281 exit 1
282 282 fi
283 283 fi
284 284 fi
285 285 SHELL=${CONFIG_SHELL-/bin/sh}
286 286 export SHELL
287 287 # Unset more variables known to interfere with behavior of common tools.
288 288 CLICOLOR_FORCE= GREP_OPTIONS=
289 289 unset CLICOLOR_FORCE GREP_OPTIONS
290 290
291 291 ## --------------------- ##
292 292 ## M4sh Shell Functions. ##
293 293 ## --------------------- ##
294 294 # as_fn_unset VAR
295 295 # ---------------
296 296 # Portably unset VAR.
297 297 as_fn_unset ()
298 298 {
299 299 { eval $1=; unset $1;}
300 300 }
301 301 as_unset=as_fn_unset
302 302
303 303 # as_fn_set_status STATUS
304 304 # -----------------------
305 305 # Set $? to STATUS, without forking.
306 306 as_fn_set_status ()
307 307 {
308 308 return $1
309 309 } # as_fn_set_status
310 310
311 311 # as_fn_exit STATUS
312 312 # -----------------
313 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
314 314 as_fn_exit ()
315 315 {
316 316 set +e
317 317 as_fn_set_status $1
318 318 exit $1
319 319 } # as_fn_exit
320 320
321 321 # as_fn_mkdir_p
322 322 # -------------
323 323 # Create "$as_dir" as a directory, including parents if necessary.
324 324 as_fn_mkdir_p ()
325 325 {
326 326
327 327 case $as_dir in #(
328 328 -*) as_dir=./$as_dir;;
329 329 esac
330 330 test -d "$as_dir" || eval $as_mkdir_p || {
331 331 as_dirs=
332 332 while :; do
333 333 case $as_dir in #(
334 334 *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
335 335 *) as_qdir=$as_dir;;
336 336 esac
337 337 as_dirs="'$as_qdir' $as_dirs"
338 338 as_dir=`$as_dirname -- "$as_dir" ||
339 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
340 340 X"$as_dir" : 'X\(//\)[^/]' \| \
341 341 X"$as_dir" : 'X\(//\)$' \| \
342 342 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
343 343 $as_echo X"$as_dir" |
344 344 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
345 345 s//\1/
346 346 q
347 347 }
348 348 /^X\(\/\/\)[^/].*/{
349 349 s//\1/
350 350 q
351 351 }
352 352 /^X\(\/\/\)$/{
353 353 s//\1/
354 354 q
355 355 }
356 356 /^X\(\/\).*/{
357 357 s//\1/
358 358 q
359 359 }
360 360 s/.*/./; q'`
361 361 test -d "$as_dir" && break
362 362 done
363 363 test -z "$as_dirs" || eval "mkdir $as_dirs"
364 364 } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
365 365
366 366
367 367 } # as_fn_mkdir_p
368 368
369 369 # as_fn_executable_p FILE
370 370 # -----------------------
371 371 # Test if FILE is an executable regular file.
372 372 as_fn_executable_p ()
373 373 {
374 374 test -f "$1" && test -x "$1"
375 375 } # as_fn_executable_p
376 376 # as_fn_append VAR VALUE
377 377 # ----------------------
378 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
379 379 # advantage of any shell optimizations that allow amortized linear growth over
380 380 # repeated appends, instead of the typical quadratic growth present in naive
381 381 # implementations.
382 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
383 383 eval 'as_fn_append ()
384 384 {
385 385 eval $1+=\$2
386 386 }'
387 387 else
388 388 as_fn_append ()
389 389 {
390 390 eval $1=\$$1\$2
391 391 }
392 392 fi # as_fn_append
393 393
394 394 # as_fn_arith ARG...
395 395 # ------------------
396 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
397 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
398 398 # must be portable across $(()) and expr.
399 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
400 400 eval 'as_fn_arith ()
401 401 {
402 402 as_val=$(( $* ))
403 403 }'
404 404 else
405 405 as_fn_arith ()
406 406 {
407 407 as_val=`expr "$@" || test $? -eq 1`
408 408 }
409 409 fi # as_fn_arith
410 410
411 411
412 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
413 413 # ----------------------------------------
414 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
415 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
416 416 # script with STATUS, using 1 if that was 0.
417 417 as_fn_error ()
418 418 {
419 419 as_status=$1; test $as_status -eq 0 && as_status=1
420 420 if test "$4"; then
421 421 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
422 422 $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
423 423 fi
424 424 $as_echo "$as_me: error: $2" >&2
425 425 as_fn_exit $as_status
426 426 } # as_fn_error
427 427
428 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
429 429 test "X`expr 00001 : '.*\(...\)'`" = X001; then
430 430 as_expr=expr
431 431 else
432 432 as_expr=false
433 433 fi
434 434
435 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
436 436 as_basename=basename
437 437 else
438 438 as_basename=false
439 439 fi
440 440
441 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
442 442 as_dirname=dirname
443 443 else
444 444 as_dirname=false
445 445 fi
446 446
447 447 as_me=`$as_basename -- "$0" ||
448 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
449 449 X"$0" : 'X\(//\)$' \| \
450 450 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
451 451 $as_echo X/"$0" |
452 452 sed '/^.*\/\([^/][^/]*\)\/*$/{
453 453 s//\1/
454 454 q
455 455 }
456 456 /^X\/\(\/\/\)$/{
457 457 s//\1/
458 458 q
459 459 }
460 460 /^X\/\(\/\).*/{
461 461 s//\1/
462 462 q
463 463 }
464 464 s/.*/./; q'`
465 465
466 466 # Avoid depending upon Character Ranges.
467 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
468 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
469 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
470 470 as_cr_digits='0123456789'
471 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
472 472
473 473
474 474 as_lineno_1=$LINENO as_lineno_1a=$LINENO
475 475 as_lineno_2=$LINENO as_lineno_2a=$LINENO
476 476 eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
477 477 test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
478 478 # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
479 479 sed -n '
480 480 p
481 481 /[$]LINENO/=
482 482 ' <$as_myself |
483 483 sed '
484 484 s/[$]LINENO.*/&-/
485 485 t lineno
486 486 b
487 487 :lineno
488 488 N
489 489 :loop
490 490 s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
491 491 t loop
492 492 s/-\n.*//
493 493 ' >$as_me.lineno &&
494 494 chmod +x "$as_me.lineno" ||
495 495 { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
496 496
497 497 # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
498 498 # already done that, so ensure we don't try to do so again and fall
499 499 # in an infinite loop. This has already happened in practice.
500 500 _as_can_reexec=no; export _as_can_reexec
501 501 # Don't try to exec as it changes $[0], causing all sort of problems
502 502 # (the dirname of $[0] is not the place where we might find the
503 503 # original and so on. Autoconf is especially sensitive to this).
504 504 . "./$as_me.lineno"
505 505 # Exit status is that of the last command.
506 506 exit
507 507 }
508 508
509 509 ECHO_C= ECHO_N= ECHO_T=
510 510 case `echo -n x` in #(((((
511 511 -n*)
512 512 case `echo 'xy\c'` in
513 513 *c*) ECHO_T=' ';; # ECHO_T is single tab character.
514 514 xy) ECHO_C='\c';;
515 515 *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
516 516 ECHO_T=' ';;
517 517 esac;;
518 518 *)
519 519 ECHO_N='-n';;
520 520 esac
521 521
522 522 rm -f conf$$ conf$$.exe conf$$.file
523 523 if test -d conf$$.dir; then
524 524 rm -f conf$$.dir/conf$$.file
525 525 else
526 526 rm -f conf$$.dir
527 527 mkdir conf$$.dir 2>/dev/null
528 528 fi
529 529 if (echo >conf$$.file) 2>/dev/null; then
530 530 if ln -s conf$$.file conf$$ 2>/dev/null; then
531 531 as_ln_s='ln -s'
532 532 # ... but there are two gotchas:
533 533 # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
534 534 # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
535 535 # In both cases, we have to default to `cp -pR'.
536 536 ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
537 537 as_ln_s='cp -pR'
538 538 elif ln conf$$.file conf$$ 2>/dev/null; then
539 539 as_ln_s=ln
540 540 else
541 541 as_ln_s='cp -pR'
542 542 fi
543 543 else
544 544 as_ln_s='cp -pR'
545 545 fi
546 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
547 547 rmdir conf$$.dir 2>/dev/null
548 548
549 549 if mkdir -p . 2>/dev/null; then
550 550 as_mkdir_p='mkdir -p "$as_dir"'
551 551 else
552 552 test -d ./-p && rmdir ./-p
553 553 as_mkdir_p=false
554 554 fi
555 555
556 556 as_test_x='test -x'
557 557 as_executable_p=as_fn_executable_p
558 558
559 559 # Sed expression to map a string onto a valid CPP name.
560 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
561 561
562 562 # Sed expression to map a string onto a valid variable name.
563 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
564 564
565 565
566 566 test -n "$DJDIR" || exec 7<&0 </dev/null
567 567 exec 6>&1
568 568
569 569 # Name of the host.
570 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
571 571 # so uname gets run too.
572 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
573 573
574 574 #
575 575 # Initializations.
576 576 #
577 577 ac_default_prefix=/usr/local
578 578 ac_clean_files=
579 579 ac_config_libobj_dir=.
580 580 LIBOBJS=
581 581 cross_compiling=no
582 582 subdirs=
583 583 MFLAGS=
584 584 MAKEFLAGS=
585 585
586 586 # Identity of this package.
587 587 PACKAGE_NAME='OpenJDK'
588 588 PACKAGE_TARNAME='openjdk'
589 589 PACKAGE_VERSION='jdk9'
590 590 PACKAGE_STRING='OpenJDK jdk9'
591 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
592 592 PACKAGE_URL='http://openjdk.java.net'
593 593
594 594 # Factoring default headers for most tests.
595 595 ac_includes_default="\
596 596 #include <stdio.h>
597 597 #ifdef HAVE_SYS_TYPES_H
598 598 # include <sys/types.h>
599 599 #endif
600 600 #ifdef HAVE_SYS_STAT_H
601 601 # include <sys/stat.h>
602 602 #endif
603 603 #ifdef STDC_HEADERS
604 604 # include <stdlib.h>
605 605 # include <stddef.h>
606 606 #else
607 607 # ifdef HAVE_STDLIB_H
608 608 # include <stdlib.h>
609 609 # endif
610 610 #endif
611 611 #ifdef HAVE_STRING_H
612 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
613 613 # include <memory.h>
614 614 # endif
615 615 # include <string.h>
616 616 #endif
617 617 #ifdef HAVE_STRINGS_H
618 618 # include <strings.h>
619 619 #endif
620 620 #ifdef HAVE_INTTYPES_H
621 621 # include <inttypes.h>
622 622 #endif
623 623 #ifdef HAVE_STDINT_H
624 624 # include <stdint.h>
625 625 #endif
626 626 #ifdef HAVE_UNISTD_H
627 627 # include <unistd.h>
628 628 #endif"
629 629
630 630 ac_subst_vars='LTLIBOBJS
631 631 LIBOBJS
632 632 CFLAGS_CCACHE
633 633 CCACHE
634 634 USE_PRECOMPILED_HEADER
635 635 BUILD_ICECC
636 636 ICECC
637 637 ICECC_WRAPPER
638 638 ICECC_CREATE_ENV
639 639 ICECC_CMD
640 640 ENABLE_JAVAC_SERVER
641 641 ENABLE_SJAVAC
642 642 SJAVAC_SERVER_JAVA_FLAGS
643 643 SJAVAC_SERVER_JAVA
644 644 JAVA_TOOL_FLAGS_SMALL
645 645 JAVA_FLAGS_SMALL
646 646 JAVA_FLAGS_JAVAC
647 647 BOOTCYCLE_JVM_ARGS_BIG
648 648 JAVA_FLAGS_BIG
649 649 JAVA_FLAGS
650 650 TEST_JOBS
651 651 JOBS
652 652 MEMORY_SIZE
653 653 NUM_CORES
654 654 ENABLE_GENERATE_CLASSLIST
655 655 BUILD_FAILURE_HANDLER
656 656 ENABLE_INTREE_EC
657 657 STLPORT_LIB
658 658 LIBZIP_CAN_USE_MMAP
659 659 LIBDL
660 660 LIBM
661 661 USE_EXTERNAL_LCMS
662 662 LCMS_LIBS
663 663 LCMS_CFLAGS
664 664 USE_EXTERNAL_LIBZ
665 665 USE_EXTERNAL_LIBPNG
666 666 PNG_LIBS
667 667 PNG_CFLAGS
668 668 USE_EXTERNAL_LIBGIF
669 669 USE_EXTERNAL_LIBJPEG
670 670 LLVM_LIBS
671 671 LLVM_LDFLAGS
672 672 LLVM_CFLAGS
673 673 LLVM_CONFIG
674 674 LIBFFI_LIBS
675 675 LIBFFI_CFLAGS
676 676 ALSA_LIBS
677 677 ALSA_CFLAGS
678 678 FREETYPE_BUNDLE_LIB_PATH
679 679 FREETYPE_LIBS
680 680 FREETYPE_CFLAGS
681 681 CUPS_CFLAGS
682 682 X_EXTRA_LIBS
683 683 X_LIBS
684 684 X_PRE_LIBS
685 685 X_CFLAGS
686 686 XMKMF
687 687 MSVCP_DLL
688 688 MSVCR_DLL
689 689 LIBCXX
690 690 STATIC_CXX_SETTING
691 691 FIXPATH_DETACH_FLAG
692 692 FIXPATH
693 693 BUILD_GTEST
694 694 VALID_JVM_FEATURES
695 695 JVM_FEATURES_custom
696 696 JVM_FEATURES_zeroshark
697 697 JVM_FEATURES_zero
698 698 JVM_FEATURES_minimal
699 699 JVM_FEATURES_core
700 700 JVM_FEATURES_client
701 701 JVM_FEATURES_server
702 702 INCLUDE_DTRACE
703 703 GCOV_ENABLED
704 704 STRIP_POLICY
705 705 DEBUG_BINARIES
706 706 ZIP_EXTERNAL_DEBUG_SYMBOLS
707 707 COPY_DEBUG_SYMBOLS
708 708 COMPILE_WITH_DEBUG_SYMBOLS
709 709 CFLAGS_WARNINGS_ARE_ERRORS
710 710 BUILD_CC_DISABLE_WARNING_PREFIX
711 711 DISABLE_WARNING_PREFIX
712 712 HOTSPOT_SET_WARNINGS_AS_ERRORS
713 713 WARNINGS_AS_ERRORS
714 714 COMPILER_SUPPORTS_TARGET_BITS_FLAG
715 715 ZERO_ARCHFLAG
716 716 LDFLAGS_TESTEXE
717 717 LDFLAGS_TESTLIB
718 718 CXXFLAGS_TESTEXE
719 719 CXXFLAGS_TESTLIB
720 720 CFLAGS_TESTEXE
721 721 CFLAGS_TESTLIB
722 722 OPENJDK_BUILD_JVM_LIBS
723 723 OPENJDK_BUILD_JVM_ASFLAGS
724 724 OPENJDK_BUILD_JVM_LDFLAGS
725 725 OPENJDK_BUILD_JVM_CFLAGS
726 726 OPENJDK_BUILD_LDFLAGS_HASH_STYLE
727 727 OPENJDK_BUILD_LDFLAGS_CXX_JDK
728 728 OPENJDK_BUILD_JDKEXE_LIBS
729 729 OPENJDK_BUILD_JDKLIB_LIBS
730 730 OPENJDK_BUILD_LDFLAGS_JDKEXE
731 731 OPENJDK_BUILD_LDFLAGS_JDKLIB
732 732 OPENJDK_BUILD_CXXFLAGS_JDKEXE
733 733 OPENJDK_BUILD_CXXFLAGS_JDKLIB
734 734 OPENJDK_BUILD_CFLAGS_JDKEXE
735 735 OPENJDK_BUILD_CFLAGS_JDKLIB
736 736 OPENJDK_BUILD_CXXSTD_CXXFLAG
737 737 JVM_LIBS
738 738 JVM_ASFLAGS
739 739 JVM_LDFLAGS
740 740 JVM_CFLAGS
741 741 LDFLAGS_HASH_STYLE
742 742 LDFLAGS_CXX_JDK
743 743 JDKEXE_LIBS
744 744 JDKLIB_LIBS
745 745 LDFLAGS_JDKEXE
746 746 LDFLAGS_JDKLIB
747 747 CXXFLAGS_JDKEXE
748 748 CXXFLAGS_JDKLIB
749 749 CFLAGS_JDKEXE
750 750 CFLAGS_JDKLIB
751 751 MACOSX_VERSION_MIN
752 752 CXXSTD_CXXFLAG
753 753 CXX_O_FLAG_SIZE
754 754 CXX_O_FLAG_NONE
755 755 CXX_O_FLAG_DEBUG
756 756 CXX_O_FLAG_NORM
757 757 CXX_O_FLAG_HI
758 758 CXX_O_FLAG_HIGHEST
759 759 CXX_O_FLAG_HIGHEST_JVM
760 760 C_O_FLAG_SIZE
761 761 C_O_FLAG_NONE
762 762 C_O_FLAG_DEBUG
763 763 C_O_FLAG_NORM
764 764 C_O_FLAG_HI
765 765 C_O_FLAG_HIGHEST
766 766 C_O_FLAG_HIGHEST_JVM
767 767 JVM_CFLAGS_SYMBOLS
768 768 CXXFLAGS_DEBUG_SYMBOLS
769 769 CFLAGS_DEBUG_SYMBOLS
770 770 CXX_FLAG_DEPS
771 771 C_FLAG_DEPS
772 772 SHARED_LIBRARY_FLAGS
773 773 SET_SHARED_LIBRARY_MAPFILE
774 774 SET_SHARED_LIBRARY_NAME
775 775 SET_SHARED_LIBRARY_ORIGIN
776 776 SET_EXECUTABLE_ORIGIN
777 777 CXX_FLAG_REORDER
778 778 C_FLAG_REORDER
779 779 JVM_RCFLAGS
780 780 RC_FLAGS
781 781 AR_OUT_OPTION
782 782 LD_OUT_OPTION
783 783 EXE_OUT_OPTION
784 784 CC_OUT_OPTION
785 785 STRIPFLAGS
786 786 ARFLAGS
787 787 COMPILER_BINDCMD_FILE_FLAG
788 788 COMPILER_COMMAND_FILE_FLAG
789 789 COMPILER_TARGET_BITS_FLAG
790 790 JT_HOME
791 791 JTREGEXE
792 792 HOTSPOT_TOOLCHAIN_TYPE
793 793 USING_BROKEN_SUSE_LD
794 794 PACKAGE_PATH
795 795 USE_CLANG
796 796 HOTSPOT_LD
797 797 HOTSPOT_CXX
798 798 HOTSPOT_RC
799 799 HOTSPOT_MT
800 800 BUILD_AS
801 801 BUILD_LDCXX
802 802 BUILD_LD
803 803 BUILD_STRIP
804 804 BUILD_OBJCOPY
805 805 BUILD_AR
806 806 BUILD_NM
807 807 BUILD_CXX
808 808 BUILD_CC
809 809 BUILD_SYSROOT_LDFLAGS
810 810 BUILD_SYSROOT_CFLAGS
811 811 ac_ct_OBJDUMP
812 812 OBJDUMP
813 813 ac_ct_OBJCOPY
814 814 OBJCOPY
815 815 ac_ct_NM
816 816 ac_ct_STRIP
817 817 GNM
818 818 NM
819 819 STRIP
820 820 MSBUILD
821 821 DUMPBIN
822 822 RC
823 823 MT
824 824 LIPO
825 825 ac_ct_AR
826 826 AR
827 827 AS
828 828 LDCXX
829 829 LD
830 830 CXXCPP
831 831 CPP
832 832 CXX_VERSION_NUMBER
833 833 CC_VERSION_NUMBER
834 834 ac_ct_CXX
835 835 CXXFLAGS
836 836 CXX
837 837 TOOLCHAIN_PATH_CXX
838 838 POTENTIAL_CXX
839 839 OBJEXT
840 840 EXEEXT
841 841 ac_ct_CC
842 842 CPPFLAGS
843 843 LDFLAGS
844 844 CFLAGS
845 845 CC
846 846 TOOLCHAIN_PATH_CC
847 847 POTENTIAL_CC
848 848 TOOLCHAIN_VERSION
849 849 VS_LIB
850 850 VS_INCLUDE
851 851 VS_PATH
852 852 CYGWIN_LINK
853 853 SYSROOT_LDFLAGS
854 854 SYSROOT_CFLAGS
855 855 EXTRA_LDFLAGS
856 856 EXTRA_CXXFLAGS
857 857 EXTRA_CFLAGS
858 858 LEGACY_EXTRA_LDFLAGS
859 859 LEGACY_EXTRA_CXXFLAGS
860 860 LEGACY_EXTRA_CFLAGS
861 861 EXE_SUFFIX
862 862 OBJ_SUFFIX
863 863 STATIC_LIBRARY
864 864 SHARED_LIBRARY
865 865 STATIC_LIBRARY_SUFFIX
866 866 SHARED_LIBRARY_SUFFIX
867 867 LIBRARY_PREFIX
868 868 TOOLCHAIN_TYPE
869 869 STATIC_BUILD
870 870 IMPORT_MODULES_MAKE
871 871 IMPORT_MODULES_SRC
872 872 IMPORT_MODULES_CONF
873 873 IMPORT_MODULES_LIBS
874 874 IMPORT_MODULES_CMDS
875 875 IMPORT_MODULES_CLASSES
876 876 BUILD_HOTSPOT
877 877 HOTSPOT_DIST
878 878 BUILD_OUTPUT
879 879 JDK_TOPDIR
880 880 NASHORN_TOPDIR
881 881 HOTSPOT_TOPDIR
882 882 JAXWS_TOPDIR
883 883 JAXP_TOPDIR
884 884 CORBA_TOPDIR
885 885 LANGTOOLS_TOPDIR
886 886 EXTERNAL_BUILDJDK
887 887 BUILD_JDK
888 888 CREATE_BUILDJDK
889 889 JLINK
890 890 JMOD
891 891 BOOT_JDK_BITS
892 892 JAVAC_FLAGS
893 893 BOOT_JDK_MODULAR
894 894 BOOT_JDK_SOURCETARGET
895 895 JARSIGNER
896 896 JAR
897 897 JAVAH
898 898 JAVAC
899 899 JAVA
900 900 BOOT_JDK
901 901 JAVA_CHECK
902 902 JAVAC_CHECK
903 903 VERSION_IS_GA
904 904 VERSION_SHORT
905 905 VERSION_STRING
906 906 VERSION_NUMBER_FOUR_POSITIONS
907 907 VERSION_NUMBER
908 908 VERSION_OPT
909 909 VERSION_BUILD
910 910 VERSION_PRE
911 911 VERSION_PATCH
912 912 VERSION_SECURITY
913 913 VERSION_MINOR
914 914 VERSION_MAJOR
915 915 MACOSX_BUNDLE_ID_BASE
916 916 MACOSX_BUNDLE_NAME_BASE
917 917 HOTSPOT_VM_DISTRO
918 918 COMPANY_NAME
919 919 JDK_RC_PLATFORM_NAME
920 920 PRODUCT_SUFFIX
921 921 PRODUCT_NAME
922 922 LAUNCHER_NAME
923 923 JLINK_KEEP_PACKAGED_MODULES
924 924 COPYRIGHT_YEAR
925 925 COMPRESS_JARS
926 926 INCLUDE_SA
927 927 UNLIMITED_CRYPTO
928 928 CACERTS_FILE
929 929 BUILD_HEADLESS
930 930 SUPPORT_HEADFUL
931 931 SUPPORT_HEADLESS
932 932 DEFAULT_MAKE_TARGET
933 933 OS_VERSION_MICRO
934 934 OS_VERSION_MINOR
935 935 OS_VERSION_MAJOR
936 936 PKG_CONFIG
937 937 BASH_ARGS
938 938 SETFILE
939 939 CODESIGN
940 940 XATTR
941 941 DSYMUTIL
942 942 IS_GNU_TIME
943 943 PATCH
944 944 DTRACE
945 945 TIME
946 946 STAT
947 947 HG
948 948 READELF
949 949 OTOOL
950 950 LDD
951 951 ZIP
952 952 UNZIP
953 953 TAR_SUPPORTS_TRANSFORM
954 954 TAR_INCLUDE_PARAM
955 955 TAR_CREATE_EXTRA_PARAM
956 956 TAR_TYPE
957 957 FIND_DELETE
958 958 OUTPUT_SYNC
959 959 OUTPUT_SYNC_SUPPORTED
960 960 CHECK_TOOLSDIR_MAKE
961 961 CHECK_TOOLSDIR_GMAKE
962 962 CHECK_MAKE
963 963 CHECK_GMAKE
964 964 MAKE
965 965 PKGHANDLER
966 966 CONFIGURESUPPORT_OUTPUTDIR
967 967 OUTPUT_ROOT
968 968 CONF_NAME
969 969 SPEC
970 970 SDKROOT
971 971 XCODEBUILD
972 972 VALID_JVM_VARIANTS
973 973 JVM_VARIANTS
974 974 DEBUG_LEVEL
975 975 HOTSPOT_DEBUG_LEVEL
976 976 JDK_VARIANT
977 977 USERNAME
978 978 CANONICAL_TOPDIR
979 979 ORIGINAL_TOPDIR
980 980 TOPDIR
981 981 PATH_SEP
982 982 ZERO_ARCHDEF
983 983 HOTSPOT_BUILD_CPU_DEFINE
984 984 HOTSPOT_BUILD_CPU_ARCH
985 985 HOTSPOT_BUILD_CPU
986 986 HOTSPOT_BUILD_OS_TYPE
987 987 HOTSPOT_BUILD_OS
988 988 OPENJDK_BUILD_BUNDLE_PLATFORM
989 989 OPENJDK_BUILD_CPU_BUNDLE
990 990 OPENJDK_BUILD_OS_BUNDLE
991 991 OPENJDK_BUILD_OS_EXPORT_DIR
992 992 OPENJDK_BUILD_CPU_JLI_CFLAGS
993 993 OPENJDK_BUILD_CPU_OSARCH
994 994 OPENJDK_BUILD_CPU_ISADIR
995 995 OPENJDK_BUILD_CPU_LIBDIR
996 996 OPENJDK_BUILD_CPU_LEGACY_LIB
997 997 OPENJDK_BUILD_CPU_LEGACY
998 998 HOTSPOT_TARGET_CPU_DEFINE
999 999 HOTSPOT_TARGET_CPU_ARCH
1000 1000 HOTSPOT_TARGET_CPU
1001 1001 HOTSPOT_TARGET_OS_TYPE
1002 1002 HOTSPOT_TARGET_OS
1003 1003 DEFINE_CROSS_COMPILE_ARCH
1004 1004 LP64
1005 1005 OPENJDK_TARGET_BUNDLE_PLATFORM
1006 1006 OPENJDK_TARGET_CPU_BUNDLE
1007 1007 OPENJDK_TARGET_OS_BUNDLE
1008 1008 OPENJDK_TARGET_OS_EXPORT_DIR
1009 1009 OPENJDK_TARGET_CPU_JLI_CFLAGS
1010 1010 OPENJDK_TARGET_CPU_OSARCH
1011 1011 OPENJDK_TARGET_CPU_ISADIR
1012 1012 OPENJDK_TARGET_CPU_LIBDIR
1013 1013 OPENJDK_TARGET_CPU_LEGACY_LIB
1014 1014 OPENJDK_TARGET_CPU_LEGACY
1015 1015 REQUIRED_OS_VERSION
1016 1016 REQUIRED_OS_NAME
1017 1017 COMPILE_TYPE
1018 1018 OPENJDK_TARGET_CPU_ENDIAN
1019 1019 OPENJDK_TARGET_CPU_BITS
1020 1020 OPENJDK_TARGET_CPU_ARCH
1021 1021 OPENJDK_TARGET_CPU
1022 1022 OPENJDK_TARGET_OS_ENV
1023 1023 OPENJDK_TARGET_OS_TYPE
1024 1024 OPENJDK_TARGET_OS
1025 1025 OPENJDK_BUILD_CPU_ENDIAN
1026 1026 OPENJDK_BUILD_CPU_BITS
1027 1027 OPENJDK_BUILD_CPU_ARCH
1028 1028 OPENJDK_BUILD_CPU
1029 1029 OPENJDK_BUILD_OS_ENV
1030 1030 OPENJDK_BUILD_OS_TYPE
1031 1031 OPENJDK_BUILD_OS
1032 1032 OPENJDK_BUILD_AUTOCONF_NAME
1033 1033 OPENJDK_TARGET_AUTOCONF_NAME
1034 1034 target_os
1035 1035 target_vendor
1036 1036 target_cpu
1037 1037 target
1038 1038 host_os
1039 1039 host_vendor
1040 1040 host_cpu
1041 1041 host
1042 1042 build_os
1043 1043 build_vendor
1044 1044 build_cpu
1045 1045 build
1046 1046 NICE
1047 1047 CPIO
1048 1048 DF
1049 1049 READLINK
1050 1050 CYGPATH
1051 1051 SED
1052 1052 FGREP
1053 1053 EGREP
1054 1054 GREP
1055 1055 AWK
1056 1056 XARGS
1057 1057 WHICH
1058 1058 WC
1059 1059 UNIQ
1060 1060 UNAME
1061 1061 TR
1062 1062 TOUCH
1063 1063 TEE
1064 1064 TAR
1065 1065 TAIL
1066 1066 SORT
1067 1067 SH
1068 1068 RMDIR
1069 1069 RM
1070 1070 PRINTF
1071 1071 NAWK
1072 1072 MV
1073 1073 MKTEMP
1074 1074 MKDIR
1075 1075 LS
1076 1076 LN
1077 1077 GZIP
1078 1078 GUNZIP
1079 1079 HEAD
1080 1080 FIND
1081 1081 FILE
1082 1082 EXPR
1083 1083 ECHO
1084 1084 DIRNAME
1085 1085 DIFF
1086 1086 DATE
1087 1087 CUT
1088 1088 CP
1089 1089 COMM
1090 1090 CMP
1091 1091 CHMOD
1092 1092 CAT
1093 1093 BASH
1094 1094 BASENAME
1095 1095 DATE_WHEN_CONFIGURED
1096 1096 ORIGINAL_PATH
1097 1097 CONFIGURE_COMMAND_LINE
1098 1098 target_alias
1099 1099 host_alias
1100 1100 build_alias
1101 1101 LIBS
1102 1102 ECHO_T
1103 1103 ECHO_N
1104 1104 ECHO_C
1105 1105 DEFS
1106 1106 mandir
1107 1107 localedir
1108 1108 libdir
1109 1109 psdir
1110 1110 pdfdir
1111 1111 dvidir
1112 1112 htmldir
1113 1113 infodir
1114 1114 docdir
1115 1115 oldincludedir
1116 1116 includedir
1117 1117 localstatedir
1118 1118 sharedstatedir
1119 1119 sysconfdir
1120 1120 datadir
1121 1121 datarootdir
1122 1122 libexecdir
1123 1123 sbindir
1124 1124 bindir
1125 1125 program_transform_name
1126 1126 prefix
1127 1127 exec_prefix
1128 1128 PACKAGE_URL
1129 1129 PACKAGE_BUGREPORT
1130 1130 PACKAGE_STRING
1131 1131 PACKAGE_VERSION
1132 1132 PACKAGE_TARNAME
1133 1133 PACKAGE_NAME
1134 1134 PATH_SEPARATOR
1135 1135 SHELL'
1136 1136 ac_subst_files=''
1137 1137 ac_user_opts='
1138 1138 enable_option_checking
1139 1139 with_target_bits
1140 1140 enable_openjdk_only
1141 1141 with_custom_make_dir
1142 1142 with_jdk_variant
1143 1143 enable_debug
1144 1144 with_debug_level
1145 1145 with_jvm_variants
1146 1146 with_devkit
1147 1147 with_sys_root
1148 1148 with_sysroot
1149 1149 with_tools_dir
1150 1150 with_toolchain_path
1151 1151 with_extra_path
1152 1152 with_sdk_name
1153 1153 with_conf_name
1154 1154 with_output_sync
1155 1155 with_default_make_target
1156 1156 enable_headful
1157 1157 with_cacerts_file
1158 1158 enable_unlimited_crypto
1159 1159 with_copyright_year
1160 1160 enable_keep_packaged_modules
1161 1161 with_milestone
1162 1162 with_update_version
1163 1163 with_user_release_suffix
1164 1164 with_build_number
1165 1165 with_version_string
1166 1166 with_version_pre
1167 1167 with_version_opt
1168 1168 with_version_build
1169 1169 with_version_major
1170 1170 with_version_minor
1171 1171 with_version_security
1172 1172 with_version_patch
1173 1173 with_boot_jdk
1174 1174 with_build_jdk
1175 1175 with_add_source_root
1176 1176 with_override_source_root
1177 1177 with_adds_and_overrides
1178 1178 with_override_langtools
1179 1179 with_override_corba
1180 1180 with_override_jaxp
1181 1181 with_override_jaxws
1182 1182 with_override_hotspot
1183 1183 with_override_nashorn
1184 1184 with_override_jdk
1185 1185 with_import_hotspot
1186 1186 with_import_modules
1187 1187 enable_static_build
1188 1188 with_toolchain_type
1189 1189 with_extra_cflags
1190 1190 with_extra_cxxflags
1191 1191 with_extra_ldflags
1192 1192 with_toolchain_version
1193 1193 with_build_devkit
1194 1194 with_jtreg
1195 1195 enable_warnings_as_errors
1196 1196 with_native_debug_symbols
1197 1197 enable_debug_symbols
1198 1198 enable_zip_debug_info
1199 1199 enable_native_coverage
1200 1200 enable_dtrace
1201 1201 with_jvm_features
1202 1202 with_jvm_interpreter
1203 1203 enable_hotspot_gtest
1204 1204 with_stdc__lib
1205 1205 with_msvcr_dll
1206 1206 with_msvcp_dll
1207 1207 with_x
1208 1208 with_cups
1209 1209 with_cups_include
1210 1210 with_freetype
1211 1211 with_freetype_include
1212 1212 with_freetype_lib
1213 1213 with_freetype_src
1214 1214 enable_freetype_bundling
1215 1215 with_alsa
1216 1216 with_alsa_include
1217 1217 with_alsa_lib
1218 1218 with_libffi
1219 1219 with_libffi_include
1220 1220 with_libffi_lib
1221 1221 with_libjpeg
1222 1222 with_giflib
1223 1223 with_libpng
1224 1224 with_zlib
1225 1225 with_lcms
1226 1226 with_dxsdk
1227 1227 with_dxsdk_lib
1228 1228 with_dxsdk_include
1229 1229 enable_jtreg_failure_handler
1230 1230 enable_generate_classlist
1231 1231 with_num_cores
1232 1232 with_memory_size
1233 1233 with_jobs
1234 1234 with_test_jobs
1235 1235 with_boot_jdk_jvmargs
1236 1236 with_sjavac_server_java
1237 1237 enable_sjavac
1238 1238 enable_javac_server
1239 1239 enable_icecc
1240 1240 enable_precompiled_headers
1241 1241 enable_ccache
1242 1242 with_ccache_dir
1243 1243 '
1244 1244 ac_precious_vars='build_alias
1245 1245 host_alias
1246 1246 target_alias
1247 1247 BASENAME
1248 1248 BASH
1249 1249 CAT
1250 1250 CHMOD
1251 1251 CMP
1252 1252 COMM
1253 1253 CP
1254 1254 CUT
1255 1255 DATE
1256 1256 DIFF
1257 1257 DIRNAME
1258 1258 ECHO
1259 1259 EXPR
1260 1260 FILE
1261 1261 FIND
1262 1262 HEAD
1263 1263 GUNZIP
1264 1264 GZIP
1265 1265 LN
1266 1266 LS
1267 1267 MKDIR
1268 1268 MKTEMP
1269 1269 MV
1270 1270 NAWK
1271 1271 PRINTF
1272 1272 RM
1273 1273 RMDIR
1274 1274 SH
1275 1275 SORT
1276 1276 TAIL
1277 1277 TAR
1278 1278 TEE
1279 1279 TOUCH
1280 1280 TR
1281 1281 UNAME
1282 1282 UNIQ
1283 1283 WC
1284 1284 WHICH
1285 1285 XARGS
1286 1286 AWK
1287 1287 GREP
1288 1288 EGREP
1289 1289 FGREP
1290 1290 SED
1291 1291 CYGPATH
1292 1292 READLINK
1293 1293 DF
1294 1294 CPIO
1295 1295 NICE
1296 1296 MAKE
1297 1297 UNZIP
1298 1298 ZIP
1299 1299 LDD
1300 1300 OTOOL
1301 1301 READELF
1302 1302 HG
1303 1303 STAT
1304 1304 TIME
1305 1305 DTRACE
1306 1306 PATCH
1307 1307 DSYMUTIL
1308 1308 XATTR
1309 1309 CODESIGN
1310 1310 SETFILE
1311 1311 PKG_CONFIG
1312 1312 JAVA
1313 1313 JAVAC
1314 1314 JAVAH
1315 1315 JAR
1316 1316 JARSIGNER
1317 1317 CC
1318 1318 CFLAGS
1319 1319 LDFLAGS
1320 1320 LIBS
1321 1321 CPPFLAGS
1322 1322 CXX
1323 1323 CXXFLAGS
1324 1324 CCC
1325 1325 CPP
1326 1326 CXXCPP
1327 1327 AS
1328 1328 AR
1329 1329 LIPO
1330 1330 STRIP
1331 1331 NM
1332 1332 GNM
1333 1333 OBJCOPY
1334 1334 OBJDUMP
1335 1335 BUILD_CC
1336 1336 BUILD_CXX
1337 1337 BUILD_NM
1338 1338 BUILD_AR
1339 1339 BUILD_OBJCOPY
1340 1340 BUILD_STRIP
1341 1341 JTREGEXE
1342 1342 XMKMF
1343 1343 FREETYPE_CFLAGS
1344 1344 FREETYPE_LIBS
1345 1345 ALSA_CFLAGS
1346 1346 ALSA_LIBS
1347 1347 LIBFFI_CFLAGS
1348 1348 LIBFFI_LIBS
1349 1349 PNG_CFLAGS
1350 1350 PNG_LIBS
1351 1351 LCMS_CFLAGS
1352 1352 LCMS_LIBS
1353 1353 ICECC_CMD
1354 1354 ICECC_CREATE_ENV
1355 1355 ICECC_WRAPPER
1356 1356 CCACHE'
1357 1357
1358 1358
1359 1359 # Initialize some variables set by options.
1360 1360 ac_init_help=
1361 1361 ac_init_version=false
1362 1362 ac_unrecognized_opts=
1363 1363 ac_unrecognized_sep=
1364 1364 # The variables have the same names as the options, with
1365 1365 # dashes changed to underlines.
1366 1366 cache_file=/dev/null
1367 1367 exec_prefix=NONE
1368 1368 no_create=
1369 1369 no_recursion=
1370 1370 prefix=NONE
1371 1371 program_prefix=NONE
1372 1372 program_suffix=NONE
1373 1373 program_transform_name=s,x,x,
1374 1374 silent=
1375 1375 site=
1376 1376 srcdir=
1377 1377 verbose=
1378 1378 x_includes=NONE
1379 1379 x_libraries=NONE
1380 1380
1381 1381 # Installation directory options.
1382 1382 # These are left unexpanded so users can "make install exec_prefix=/foo"
1383 1383 # and all the variables that are supposed to be based on exec_prefix
1384 1384 # by default will actually change.
1385 1385 # Use braces instead of parens because sh, perl, etc. also accept them.
1386 1386 # (The list follows the same order as the GNU Coding Standards.)
1387 1387 bindir='${exec_prefix}/bin'
1388 1388 sbindir='${exec_prefix}/sbin'
1389 1389 libexecdir='${exec_prefix}/libexec'
1390 1390 datarootdir='${prefix}/share'
1391 1391 datadir='${datarootdir}'
1392 1392 sysconfdir='${prefix}/etc'
1393 1393 sharedstatedir='${prefix}/com'
1394 1394 localstatedir='${prefix}/var'
1395 1395 includedir='${prefix}/include'
1396 1396 oldincludedir='/usr/include'
1397 1397 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1398 1398 infodir='${datarootdir}/info'
1399 1399 htmldir='${docdir}'
1400 1400 dvidir='${docdir}'
1401 1401 pdfdir='${docdir}'
1402 1402 psdir='${docdir}'
1403 1403 libdir='${exec_prefix}/lib'
1404 1404 localedir='${datarootdir}/locale'
1405 1405 mandir='${datarootdir}/man'
1406 1406
1407 1407 ac_prev=
1408 1408 ac_dashdash=
1409 1409 for ac_option
1410 1410 do
1411 1411 # If the previous option needs an argument, assign it.
1412 1412 if test -n "$ac_prev"; then
1413 1413 eval $ac_prev=\$ac_option
1414 1414 ac_prev=
1415 1415 continue
1416 1416 fi
1417 1417
1418 1418 case $ac_option in
1419 1419 *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1420 1420 *=) ac_optarg= ;;
1421 1421 *) ac_optarg=yes ;;
1422 1422 esac
1423 1423
1424 1424 # Accept the important Cygnus configure options, so we can diagnose typos.
1425 1425
1426 1426 case $ac_dashdash$ac_option in
1427 1427 --)
1428 1428 ac_dashdash=yes ;;
1429 1429
1430 1430 -bindir | --bindir | --bindi | --bind | --bin | --bi)
1431 1431 ac_prev=bindir ;;
1432 1432 -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1433 1433 bindir=$ac_optarg ;;
1434 1434
1435 1435 -build | --build | --buil | --bui | --bu)
1436 1436 ac_prev=build_alias ;;
1437 1437 -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1438 1438 build_alias=$ac_optarg ;;
1439 1439
1440 1440 -cache-file | --cache-file | --cache-fil | --cache-fi \
1441 1441 | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1442 1442 ac_prev=cache_file ;;
1443 1443 -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1444 1444 | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1445 1445 cache_file=$ac_optarg ;;
1446 1446
1447 1447 --config-cache | -C)
1448 1448 cache_file=config.cache ;;
1449 1449
1450 1450 -datadir | --datadir | --datadi | --datad)
1451 1451 ac_prev=datadir ;;
1452 1452 -datadir=* | --datadir=* | --datadi=* | --datad=*)
1453 1453 datadir=$ac_optarg ;;
1454 1454
1455 1455 -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1456 1456 | --dataroo | --dataro | --datar)
1457 1457 ac_prev=datarootdir ;;
1458 1458 -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1459 1459 | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1460 1460 datarootdir=$ac_optarg ;;
1461 1461
1462 1462 -disable-* | --disable-*)
1463 1463 ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1464 1464 # Reject names that are not valid shell variable names.
1465 1465 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1466 1466 as_fn_error $? "invalid feature name: $ac_useropt"
1467 1467 ac_useropt_orig=$ac_useropt
1468 1468 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1469 1469 case $ac_user_opts in
1470 1470 *"
1471 1471 "enable_$ac_useropt"
1472 1472 "*) ;;
1473 1473 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1474 1474 ac_unrecognized_sep=', ';;
1475 1475 esac
1476 1476 eval enable_$ac_useropt=no ;;
1477 1477
1478 1478 -docdir | --docdir | --docdi | --doc | --do)
1479 1479 ac_prev=docdir ;;
1480 1480 -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1481 1481 docdir=$ac_optarg ;;
1482 1482
1483 1483 -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1484 1484 ac_prev=dvidir ;;
1485 1485 -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1486 1486 dvidir=$ac_optarg ;;
1487 1487
1488 1488 -enable-* | --enable-*)
1489 1489 ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1490 1490 # Reject names that are not valid shell variable names.
1491 1491 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1492 1492 as_fn_error $? "invalid feature name: $ac_useropt"
1493 1493 ac_useropt_orig=$ac_useropt
1494 1494 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1495 1495 case $ac_user_opts in
1496 1496 *"
1497 1497 "enable_$ac_useropt"
1498 1498 "*) ;;
1499 1499 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1500 1500 ac_unrecognized_sep=', ';;
1501 1501 esac
1502 1502 eval enable_$ac_useropt=\$ac_optarg ;;
1503 1503
1504 1504 -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1505 1505 | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1506 1506 | --exec | --exe | --ex)
1507 1507 ac_prev=exec_prefix ;;
1508 1508 -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1509 1509 | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1510 1510 | --exec=* | --exe=* | --ex=*)
1511 1511 exec_prefix=$ac_optarg ;;
1512 1512
1513 1513 -gas | --gas | --ga | --g)
1514 1514 # Obsolete; use --with-gas.
1515 1515 with_gas=yes ;;
1516 1516
1517 1517 -help | --help | --hel | --he | -h)
1518 1518 ac_init_help=long ;;
1519 1519 -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1520 1520 ac_init_help=recursive ;;
1521 1521 -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1522 1522 ac_init_help=short ;;
1523 1523
1524 1524 -host | --host | --hos | --ho)
1525 1525 ac_prev=host_alias ;;
1526 1526 -host=* | --host=* | --hos=* | --ho=*)
1527 1527 host_alias=$ac_optarg ;;
1528 1528
1529 1529 -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1530 1530 ac_prev=htmldir ;;
1531 1531 -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1532 1532 | --ht=*)
1533 1533 htmldir=$ac_optarg ;;
1534 1534
1535 1535 -includedir | --includedir | --includedi | --included | --include \
1536 1536 | --includ | --inclu | --incl | --inc)
1537 1537 ac_prev=includedir ;;
1538 1538 -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1539 1539 | --includ=* | --inclu=* | --incl=* | --inc=*)
1540 1540 includedir=$ac_optarg ;;
1541 1541
1542 1542 -infodir | --infodir | --infodi | --infod | --info | --inf)
1543 1543 ac_prev=infodir ;;
1544 1544 -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1545 1545 infodir=$ac_optarg ;;
1546 1546
1547 1547 -libdir | --libdir | --libdi | --libd)
1548 1548 ac_prev=libdir ;;
1549 1549 -libdir=* | --libdir=* | --libdi=* | --libd=*)
1550 1550 libdir=$ac_optarg ;;
1551 1551
1552 1552 -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1553 1553 | --libexe | --libex | --libe)
1554 1554 ac_prev=libexecdir ;;
1555 1555 -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1556 1556 | --libexe=* | --libex=* | --libe=*)
1557 1557 libexecdir=$ac_optarg ;;
1558 1558
1559 1559 -localedir | --localedir | --localedi | --localed | --locale)
1560 1560 ac_prev=localedir ;;
1561 1561 -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1562 1562 localedir=$ac_optarg ;;
1563 1563
1564 1564 -localstatedir | --localstatedir | --localstatedi | --localstated \
1565 1565 | --localstate | --localstat | --localsta | --localst | --locals)
1566 1566 ac_prev=localstatedir ;;
1567 1567 -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1568 1568 | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1569 1569 localstatedir=$ac_optarg ;;
1570 1570
1571 1571 -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1572 1572 ac_prev=mandir ;;
1573 1573 -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1574 1574 mandir=$ac_optarg ;;
1575 1575
1576 1576 -nfp | --nfp | --nf)
1577 1577 # Obsolete; use --without-fp.
1578 1578 with_fp=no ;;
1579 1579
1580 1580 -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1581 1581 | --no-cr | --no-c | -n)
1582 1582 no_create=yes ;;
1583 1583
1584 1584 -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1585 1585 | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1586 1586 no_recursion=yes ;;
1587 1587
1588 1588 -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1589 1589 | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1590 1590 | --oldin | --oldi | --old | --ol | --o)
1591 1591 ac_prev=oldincludedir ;;
1592 1592 -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1593 1593 | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1594 1594 | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1595 1595 oldincludedir=$ac_optarg ;;
1596 1596
1597 1597 -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1598 1598 ac_prev=prefix ;;
1599 1599 -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1600 1600 prefix=$ac_optarg ;;
1601 1601
1602 1602 -program-prefix | --program-prefix | --program-prefi | --program-pref \
1603 1603 | --program-pre | --program-pr | --program-p)
1604 1604 ac_prev=program_prefix ;;
1605 1605 -program-prefix=* | --program-prefix=* | --program-prefi=* \
1606 1606 | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1607 1607 program_prefix=$ac_optarg ;;
1608 1608
1609 1609 -program-suffix | --program-suffix | --program-suffi | --program-suff \
1610 1610 | --program-suf | --program-su | --program-s)
1611 1611 ac_prev=program_suffix ;;
1612 1612 -program-suffix=* | --program-suffix=* | --program-suffi=* \
1613 1613 | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1614 1614 program_suffix=$ac_optarg ;;
1615 1615
1616 1616 -program-transform-name | --program-transform-name \
1617 1617 | --program-transform-nam | --program-transform-na \
1618 1618 | --program-transform-n | --program-transform- \
1619 1619 | --program-transform | --program-transfor \
1620 1620 | --program-transfo | --program-transf \
1621 1621 | --program-trans | --program-tran \
1622 1622 | --progr-tra | --program-tr | --program-t)
1623 1623 ac_prev=program_transform_name ;;
1624 1624 -program-transform-name=* | --program-transform-name=* \
1625 1625 | --program-transform-nam=* | --program-transform-na=* \
1626 1626 | --program-transform-n=* | --program-transform-=* \
1627 1627 | --program-transform=* | --program-transfor=* \
1628 1628 | --program-transfo=* | --program-transf=* \
1629 1629 | --program-trans=* | --program-tran=* \
1630 1630 | --progr-tra=* | --program-tr=* | --program-t=*)
1631 1631 program_transform_name=$ac_optarg ;;
1632 1632
1633 1633 -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1634 1634 ac_prev=pdfdir ;;
1635 1635 -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1636 1636 pdfdir=$ac_optarg ;;
1637 1637
1638 1638 -psdir | --psdir | --psdi | --psd | --ps)
1639 1639 ac_prev=psdir ;;
1640 1640 -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1641 1641 psdir=$ac_optarg ;;
1642 1642
1643 1643 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1644 1644 | -silent | --silent | --silen | --sile | --sil)
1645 1645 silent=yes ;;
1646 1646
1647 1647 -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1648 1648 ac_prev=sbindir ;;
1649 1649 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1650 1650 | --sbi=* | --sb=*)
1651 1651 sbindir=$ac_optarg ;;
1652 1652
1653 1653 -sharedstatedir | --sharedstatedir | --sharedstatedi \
1654 1654 | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1655 1655 | --sharedst | --shareds | --shared | --share | --shar \
1656 1656 | --sha | --sh)
1657 1657 ac_prev=sharedstatedir ;;
1658 1658 -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1659 1659 | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1660 1660 | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1661 1661 | --sha=* | --sh=*)
1662 1662 sharedstatedir=$ac_optarg ;;
1663 1663
1664 1664 -site | --site | --sit)
1665 1665 ac_prev=site ;;
1666 1666 -site=* | --site=* | --sit=*)
1667 1667 site=$ac_optarg ;;
1668 1668
1669 1669 -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1670 1670 ac_prev=srcdir ;;
1671 1671 -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1672 1672 srcdir=$ac_optarg ;;
1673 1673
1674 1674 -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1675 1675 | --syscon | --sysco | --sysc | --sys | --sy)
1676 1676 ac_prev=sysconfdir ;;
1677 1677 -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1678 1678 | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1679 1679 sysconfdir=$ac_optarg ;;
1680 1680
1681 1681 -target | --target | --targe | --targ | --tar | --ta | --t)
1682 1682 ac_prev=target_alias ;;
1683 1683 -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1684 1684 target_alias=$ac_optarg ;;
1685 1685
1686 1686 -v | -verbose | --verbose | --verbos | --verbo | --verb)
1687 1687 verbose=yes ;;
1688 1688
1689 1689 -version | --version | --versio | --versi | --vers | -V)
1690 1690 ac_init_version=: ;;
1691 1691
1692 1692 -with-* | --with-*)
1693 1693 ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1694 1694 # Reject names that are not valid shell variable names.
1695 1695 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1696 1696 as_fn_error $? "invalid package name: $ac_useropt"
1697 1697 ac_useropt_orig=$ac_useropt
1698 1698 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1699 1699 case $ac_user_opts in
1700 1700 *"
1701 1701 "with_$ac_useropt"
1702 1702 "*) ;;
1703 1703 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1704 1704 ac_unrecognized_sep=', ';;
1705 1705 esac
1706 1706 eval with_$ac_useropt=\$ac_optarg ;;
1707 1707
1708 1708 -without-* | --without-*)
1709 1709 ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1710 1710 # Reject names that are not valid shell variable names.
1711 1711 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1712 1712 as_fn_error $? "invalid package name: $ac_useropt"
1713 1713 ac_useropt_orig=$ac_useropt
1714 1714 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1715 1715 case $ac_user_opts in
1716 1716 *"
1717 1717 "with_$ac_useropt"
1718 1718 "*) ;;
1719 1719 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1720 1720 ac_unrecognized_sep=', ';;
1721 1721 esac
1722 1722 eval with_$ac_useropt=no ;;
1723 1723
1724 1724 --x)
1725 1725 # Obsolete; use --with-x.
1726 1726 with_x=yes ;;
1727 1727
1728 1728 -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1729 1729 | --x-incl | --x-inc | --x-in | --x-i)
1730 1730 ac_prev=x_includes ;;
1731 1731 -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1732 1732 | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1733 1733 x_includes=$ac_optarg ;;
1734 1734
1735 1735 -x-libraries | --x-libraries | --x-librarie | --x-librari \
1736 1736 | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1737 1737 ac_prev=x_libraries ;;
1738 1738 -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1739 1739 | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1740 1740 x_libraries=$ac_optarg ;;
1741 1741
1742 1742 -*) as_fn_error $? "unrecognized option: \`$ac_option'
1743 1743 Try \`$0 --help' for more information"
1744 1744 ;;
1745 1745
1746 1746 *=*)
1747 1747 ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1748 1748 # Reject names that are not valid shell variable names.
1749 1749 case $ac_envvar in #(
1750 1750 '' | [0-9]* | *[!_$as_cr_alnum]* )
1751 1751 as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1752 1752 esac
1753 1753 eval $ac_envvar=\$ac_optarg
1754 1754 export $ac_envvar ;;
1755 1755
1756 1756 *)
1757 1757 # FIXME: should be removed in autoconf 3.0.
1758 1758 $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1759 1759 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1760 1760 $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1761 1761 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1762 1762 ;;
1763 1763
1764 1764 esac
1765 1765 done
1766 1766
1767 1767 if test -n "$ac_prev"; then
1768 1768 ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1769 1769 as_fn_error $? "missing argument to $ac_option"
1770 1770 fi
1771 1771
1772 1772 if test -n "$ac_unrecognized_opts"; then
1773 1773 case $enable_option_checking in
1774 1774 no) ;;
1775 1775 fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1776 1776 *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1777 1777 esac
1778 1778 fi
1779 1779
1780 1780 # Check all directory arguments for consistency.
1781 1781 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
1782 1782 datadir sysconfdir sharedstatedir localstatedir includedir \
1783 1783 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1784 1784 libdir localedir mandir
1785 1785 do
1786 1786 eval ac_val=\$$ac_var
1787 1787 # Remove trailing slashes.
1788 1788 case $ac_val in
1789 1789 */ )
1790 1790 ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1791 1791 eval $ac_var=\$ac_val;;
1792 1792 esac
1793 1793 # Be sure to have absolute directory names.
1794 1794 case $ac_val in
1795 1795 [\\/$]* | ?:[\\/]* ) continue;;
1796 1796 NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1797 1797 esac
1798 1798 as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1799 1799 done
1800 1800
1801 1801 # There might be people who depend on the old broken behavior: `$host'
1802 1802 # used to hold the argument of --host etc.
1803 1803 # FIXME: To remove some day.
1804 1804 build=$build_alias
1805 1805 host=$host_alias
1806 1806 target=$target_alias
1807 1807
1808 1808 # FIXME: To remove some day.
1809 1809 if test "x$host_alias" != x; then
1810 1810 if test "x$build_alias" = x; then
1811 1811 cross_compiling=maybe
1812 1812 elif test "x$build_alias" != "x$host_alias"; then
1813 1813 cross_compiling=yes
1814 1814 fi
1815 1815 fi
1816 1816
1817 1817 ac_tool_prefix=
1818 1818 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1819 1819
1820 1820 test "$silent" = yes && exec 6>/dev/null
1821 1821
1822 1822
1823 1823 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1824 1824 ac_ls_di=`ls -di .` &&
1825 1825 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1826 1826 as_fn_error $? "working directory cannot be determined"
1827 1827 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1828 1828 as_fn_error $? "pwd does not report name of working directory"
1829 1829
1830 1830
1831 1831 # Find the source files, if location was not specified.
1832 1832 if test -z "$srcdir"; then
1833 1833 ac_srcdir_defaulted=yes
1834 1834 # Try the directory containing this script, then the parent directory.
1835 1835 ac_confdir=`$as_dirname -- "$as_myself" ||
1836 1836 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1837 1837 X"$as_myself" : 'X\(//\)[^/]' \| \
1838 1838 X"$as_myself" : 'X\(//\)$' \| \
1839 1839 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1840 1840 $as_echo X"$as_myself" |
1841 1841 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1842 1842 s//\1/
1843 1843 q
1844 1844 }
1845 1845 /^X\(\/\/\)[^/].*/{
1846 1846 s//\1/
1847 1847 q
1848 1848 }
1849 1849 /^X\(\/\/\)$/{
1850 1850 s//\1/
1851 1851 q
1852 1852 }
1853 1853 /^X\(\/\).*/{
1854 1854 s//\1/
1855 1855 q
1856 1856 }
1857 1857 s/.*/./; q'`
1858 1858 srcdir=$ac_confdir
1859 1859 if test ! -r "$srcdir/$ac_unique_file"; then
1860 1860 srcdir=..
1861 1861 fi
1862 1862 else
1863 1863 ac_srcdir_defaulted=no
1864 1864 fi
1865 1865 if test ! -r "$srcdir/$ac_unique_file"; then
1866 1866 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1867 1867 as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1868 1868 fi
1869 1869 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1870 1870 ac_abs_confdir=`(
1871 1871 cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1872 1872 pwd)`
1873 1873 # When building in place, set srcdir=.
1874 1874 if test "$ac_abs_confdir" = "$ac_pwd"; then
1875 1875 srcdir=.
1876 1876 fi
1877 1877 # Remove unnecessary trailing slashes from srcdir.
1878 1878 # Double slashes in file names in object file debugging info
1879 1879 # mess up M-x gdb in Emacs.
1880 1880 case $srcdir in
1881 1881 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1882 1882 esac
1883 1883 for ac_var in $ac_precious_vars; do
1884 1884 eval ac_env_${ac_var}_set=\${${ac_var}+set}
1885 1885 eval ac_env_${ac_var}_value=\$${ac_var}
1886 1886 eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1887 1887 eval ac_cv_env_${ac_var}_value=\$${ac_var}
1888 1888 done
1889 1889
1890 1890 #
1891 1891 # Report the --help message.
1892 1892 #
1893 1893 if test "$ac_init_help" = "long"; then
1894 1894 # Omit some internal or obsolete options to make the list less imposing.
1895 1895 # This message is too long to be a string in the A/UX 3.1 sh.
1896 1896 cat <<_ACEOF
1897 1897 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1898 1898
1899 1899 Usage: $0 [OPTION]... [VAR=VALUE]...
1900 1900
1901 1901 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1902 1902 VAR=VALUE. See below for descriptions of some of the useful variables.
1903 1903
1904 1904 Defaults for the options are specified in brackets.
1905 1905
1906 1906 Configuration:
1907 1907 -h, --help display this help and exit
1908 1908 --help=short display options specific to this package
1909 1909 --help=recursive display the short help of all the included packages
1910 1910 -V, --version display version information and exit
1911 1911 -q, --quiet, --silent do not print \`checking ...' messages
1912 1912 --cache-file=FILE cache test results in FILE [disabled]
1913 1913 -C, --config-cache alias for \`--cache-file=config.cache'
1914 1914 -n, --no-create do not create output files
1915 1915 --srcdir=DIR find the sources in DIR [configure dir or \`..']
1916 1916
1917 1917 Installation directories:
1918 1918 --prefix=PREFIX install architecture-independent files in PREFIX
1919 1919 [$ac_default_prefix]
1920 1920 --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
1921 1921 [PREFIX]
1922 1922
1923 1923 By default, \`make install' will install all the files in
1924 1924 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
1925 1925 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1926 1926 for instance \`--prefix=\$HOME'.
1927 1927
1928 1928 For better control, use the options below.
1929 1929
1930 1930 Fine tuning of the installation directories:
1931 1931 --bindir=DIR user executables [EPREFIX/bin]
1932 1932 --sbindir=DIR system admin executables [EPREFIX/sbin]
1933 1933 --libexecdir=DIR program executables [EPREFIX/libexec]
1934 1934 --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
1935 1935 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
1936 1936 --localstatedir=DIR modifiable single-machine data [PREFIX/var]
1937 1937 --libdir=DIR object code libraries [EPREFIX/lib]
1938 1938 --includedir=DIR C header files [PREFIX/include]
1939 1939 --oldincludedir=DIR C header files for non-gcc [/usr/include]
1940 1940 --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
1941 1941 --datadir=DIR read-only architecture-independent data [DATAROOTDIR]
1942 1942 --infodir=DIR info documentation [DATAROOTDIR/info]
1943 1943 --localedir=DIR locale-dependent data [DATAROOTDIR/locale]
1944 1944 --mandir=DIR man documentation [DATAROOTDIR/man]
1945 1945 --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk]
1946 1946 --htmldir=DIR html documentation [DOCDIR]
1947 1947 --dvidir=DIR dvi documentation [DOCDIR]
1948 1948 --pdfdir=DIR pdf documentation [DOCDIR]
1949 1949 --psdir=DIR ps documentation [DOCDIR]
1950 1950 _ACEOF
1951 1951
1952 1952 cat <<\_ACEOF
1953 1953
1954 1954 X features:
1955 1955 --x-includes=DIR X include files are in DIR
1956 1956 --x-libraries=DIR X library files are in DIR
1957 1957
1958 1958 System types:
1959 1959 --build=BUILD configure for building on BUILD [guessed]
1960 1960 --host=HOST cross-compile to build programs to run on HOST [BUILD]
1961 1961 --target=TARGET configure for building compilers for TARGET [HOST]
1962 1962 _ACEOF
1963 1963 fi
1964 1964
1965 1965 if test -n "$ac_init_help"; then
1966 1966 case $ac_init_help in
1967 1967 short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1968 1968 esac
1969 1969 cat <<\_ACEOF
1970 1970
1971 1971 Optional Features:
1972 1972 --disable-option-checking ignore unrecognized --enable/--with options
1973 1973 --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
1974 1974 --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
1975 1975 --enable-openjdk-only suppress building custom source even if present
1976 1976 [disabled]
1977 1977 --enable-debug set the debug level to fastdebug (shorthand for
1978 1978 --with-debug-level=fastdebug) [disabled]
1979 1979 --disable-headful disable building headful support (graphical UI
1980 1980 support) [enabled]
1981 1981 --enable-unlimited-crypto
1982 1982 Enable unlimited crypto policy [disabled]
1983 1983 --disable-keep-packaged-modules
1984 1984 Do not keep packaged modules in jdk image [enable]
1985 1985 --enable-static-build enable static library build [disabled]
1986 1986 --disable-warnings-as-errors
1987 1987 do not consider native warnings to be an error
1988 1988 [enabled]
1989 1989 --enable-debug-symbols Deprecated. Option is kept for backwards
1990 1990 compatibility and is ignored
1991 1991 --enable-zip-debug-info Deprecated. Option is kept for backwards
1992 1992 compatibility and is ignored
1993 1993 --enable-native-coverage
1994 1994 enable native compilation with code coverage
1995 1995 data[disabled]
1996 1996 --enable-dtrace[=yes/no/auto]
1997 1997 enable dtrace. Default is auto, where dtrace is
1998 1998 enabled if all dependencies are present.
1999 1999 --disable-hotspot-gtest Disables building of the Hotspot unit tests
2000 2000 --disable-freetype-bundling
2001 2001 disable bundling of the freetype library with the
2002 2002 build result [enabled on Windows or when using
2003 2003 --with-freetype, disabled otherwise]
2004 2004 --enable-jtreg-failure-handler
2005 2005 forces build of the jtreg failure handler to be
2006 2006 enabled, missing dependencies become fatal errors.
2007 2007 Default is auto, where the failure handler is built
2008 2008 if all dependencies are present and otherwise just
2009 2009 disabled.
2010 2010 --disable-generate-classlist
2011 2011 forces enabling or disabling of the generation of a
2012 2012 CDS classlist at build time. Default is to generate
2013 2013 it when either the server or client JVMs are built.
2014 2014 --enable-sjavac use sjavac to do fast incremental compiles
2015 2015 [disabled]
2016 2016 --disable-javac-server disable javac server [enabled]
2017 2017 --enable-icecc enable distribted compilation of native code using
2018 2018 icecc/icecream [disabled]
2019 2019 --disable-precompiled-headers
2020 2020 disable using precompiled headers when compiling C++
2021 2021 [enabled]
2022 2022 --enable-ccache enable using ccache to speed up recompilations
2023 2023 [disabled]
2024 2024
2025 2025 Optional Packages:
2026 2026 --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
2027 2027 --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
2028 2028 --with-target-bits build 32-bit or 64-bit binaries (for platforms that
2029 2029 support it), e.g. --with-target-bits=32 [guessed]
2030 2030 --with-custom-make-dir Deprecated. Option is kept for backwards
2031 2031 compatibility and is ignored
2032 2032 --with-jdk-variant JDK variant to build (normal) [normal]
2033 2033 --with-debug-level set the debug level (release, fastdebug, slowdebug,
2034 2034 optimized) [release]
2035 2035 --with-jvm-variants JVM variants (separated by commas) to build
2036 2036 (server,client,minimal,core,zero,zeroshark,custom)
2037 2037 [server]
2038 2038 --with-devkit use this devkit for compilers, tools and resources
2039 2039 --with-sys-root alias for --with-sysroot for backwards compatability
2040 2040 --with-sysroot use this directory as sysroot
2041 2041 --with-tools-dir alias for --with-toolchain-path for backwards
2042 2042 compatibility
2043 2043 --with-toolchain-path prepend these directories when searching for
2044 2044 toolchain binaries (compilers etc)
2045 2045 --with-extra-path prepend these directories to the default path
2046 2046 --with-sdk-name use the platform SDK of the given name. [macosx]
2047 2047 --with-conf-name use this as the name of the configuration [generated
2048 2048 from important configuration options]
2049 2049 --with-output-sync set make output sync type if supported by make.
2050 2050 [recurse]
2051 2051 --with-default-make-target
2052 2052 set the default make target [exploded-image]
2053 2053 --with-cacerts-file specify alternative cacerts file
2054 2054 --with-copyright-year Set copyright year value for build [current year]
2055 2055 --with-milestone Deprecated. Option is kept for backwards
2056 2056 compatibility and is ignored
2057 2057 --with-update-version Deprecated. Option is kept for backwards
2058 2058 compatibility and is ignored
2059 2059 --with-user-release-suffix
2060 2060 Deprecated. Option is kept for backwards
2061 2061 compatibility and is ignored
2062 2062 --with-build-number Deprecated. Option is kept for backwards
2063 2063 compatibility and is ignored
2064 2064 --with-version-string Set version string [calculated]
2065 2065 --with-version-pre Set the base part of the version 'PRE' field
2066 2066 (pre-release identifier) ['internal']
2067 2067 --with-version-opt Set version 'OPT' field (build metadata)
2068 2068 [<timestamp>.<user>.<dirname>]
2069 2069 --with-version-build Set version 'BUILD' field (build number) [not
2070 2070 specified]
2071 2071 --with-version-major Set version 'MAJOR' field (first number) [current
2072 2072 source value]
2073 2073 --with-version-minor Set version 'MINOR' field (second number) [current
2074 2074 source value]
2075 2075 --with-version-security Set version 'SECURITY' field (third number) [current
2076 2076 source value]
2077 2077 --with-version-patch Set version 'PATCH' field (fourth number) [not
2078 2078 specified]
2079 2079 --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed]
2080 2080 --with-build-jdk path to JDK of same version as is being built[the
2081 2081 newly built JDK]
2082 2082 --with-add-source-root Deprecated. Option is kept for backwards
2083 2083 compatibility and is ignored
2084 2084 --with-override-source-root
2085 2085 Deprecated. Option is kept for backwards
2086 2086 compatibility and is ignored
2087 2087 --with-adds-and-overrides
2088 2088 Deprecated. Option is kept for backwards
2089 2089 compatibility and is ignored
2090 2090 --with-override-langtools
2091 2091 Deprecated. Option is kept for backwards
2092 2092 compatibility and is ignored
2093 2093 --with-override-corba Deprecated. Option is kept for backwards
2094 2094 compatibility and is ignored
2095 2095 --with-override-jaxp Deprecated. Option is kept for backwards
2096 2096 compatibility and is ignored
2097 2097 --with-override-jaxws Deprecated. Option is kept for backwards
2098 2098 compatibility and is ignored
2099 2099 --with-override-hotspot Deprecated. Option is kept for backwards
2100 2100 compatibility and is ignored
2101 2101 --with-override-nashorn Deprecated. Option is kept for backwards
2102 2102 compatibility and is ignored
2103 2103 --with-override-jdk Deprecated. Option is kept for backwards
2104 2104 compatibility and is ignored
2105 2105 --with-import-hotspot import hotspot binaries from this jdk image or
2106 2106 hotspot build dist dir instead of building from
2107 2107 source
2108 2108 --with-import-modules import a set of prebuilt modules either as a zip
2109 2109 file or an exploded directory
2110 2110 --with-toolchain-type the toolchain type (or family) to use, use '--help'
2111 2111 to show possible values [platform dependent]
2112 2112 --with-extra-cflags extra flags to be used when compiling jdk c-files
2113 2113 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
2114 2114 --with-extra-ldflags extra flags to be used when linking jdk
2115 2115 --with-toolchain-version
2116 2116 the version of the toolchain to look for, use
2117 2117 '--help' to show possible values [platform
2118 2118 dependent]
2119 2119 --with-build-devkit Devkit to use for the build platform toolchain
2120 2120 --with-jtreg Regression Test Harness [probed]
2121 2121 --with-native-debug-symbols
2122 2122 set the native debug symbol configuration (none,
2123 2123 internal, external, zipped) [varying]
2124 2124 --with-jvm-features additional JVM features to enable (separated by
2125 2125 comma), use '--help' to show possible values [none]
2126 2126 --with-jvm-interpreter Deprecated. Option is kept for backwards
2127 2127 compatibility and is ignored
2128 2128 --with-stdc++lib=<static>,<dynamic>,<default>
2129 2129 force linking of the C++ runtime on Linux to either
2130 2130 static or dynamic, default is static with dynamic as
2131 2131 fallback
2132 2132 --with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
2133 2133 (Windows only) [probed]
2134 2134 --with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
2135 2135 (Windows only) [probed]
2136 2136 --with-x use the X Window System
2137 2137 --with-cups specify prefix directory for the cups package
2138 2138 (expecting the headers under PATH/include)
2139 2139 --with-cups-include specify directory for the cups include files
2140 2140 --with-freetype specify prefix directory for the freetype package
2141 2141 (expecting the libraries under PATH/lib and the
2142 2142 headers under PATH/include)
2143 2143 --with-freetype-include specify directory for the freetype include files
2144 2144 --with-freetype-lib specify directory for the freetype library
2145 2145 --with-freetype-src specify directory with freetype sources to
2146 2146 automatically build the library (experimental,
2147 2147 Windows-only)
2148 2148 --with-alsa specify prefix directory for the alsa package
2149 2149 (expecting the libraries under PATH/lib and the
2150 2150 headers under PATH/include)
2151 2151 --with-alsa-include specify directory for the alsa include files
2152 2152 --with-alsa-lib specify directory for the alsa library
2153 2153 --with-libffi specify prefix directory for the libffi package
2154 2154 (expecting the libraries under PATH/lib and the
2155 2155 headers under PATH/include)
2156 2156 --with-libffi-include specify directory for the libffi include files
2157 2157 --with-libffi-lib specify directory for the libffi library
2158 2158 --with-libjpeg use libjpeg from build system or OpenJDK source
2159 2159 (system, bundled) [bundled]
2160 2160 --with-giflib use giflib from build system or OpenJDK source
2161 2161 (system, bundled) [bundled]
2162 2162 --with-libpng use libpng from build system or OpenJDK source
2163 2163 (system, bundled) [bundled]
2164 2164 --with-zlib use zlib from build system or OpenJDK source
2165 2165 (system, bundled) [bundled]
2166 2166 --with-lcms use lcms2 from build system or OpenJDK source
2167 2167 (system, bundled) [bundled]
2168 2168 --with-dxsdk Deprecated. Option is kept for backwards
2169 2169 compatibility and is ignored
2170 2170 --with-dxsdk-lib Deprecated. Option is kept for backwards
2171 2171 compatibility and is ignored
2172 2172 --with-dxsdk-include Deprecated. Option is kept for backwards
2173 2173 compatibility and is ignored
2174 2174 --with-num-cores number of cores in the build system, e.g.
2175 2175 --with-num-cores=8 [probed]
2176 2176 --with-memory-size memory (in MB) available in the build system, e.g.
2177 2177 --with-memory-size=1024 [probed]
2178 2178 --with-jobs number of parallel jobs to let make run [calculated
2179 2179 based on cores and memory]
2180 2180 --with-test-jobs number of parallel tests jobs to run [based on build
2181 2181 jobs]
2182 2182 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2183 2183 invocations of boot JDK, overriding the default
2184 2184 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2185 2185 -enableassertions"
2186 2186 --with-sjavac-server-java
2187 2187 use this java binary for running the sjavac
2188 2188 background server [Boot JDK java]
2189 2189 --with-ccache-dir where to store ccache files [~/.ccache]
2190 2190
2191 2191 Some influential environment variables:
2192 2192 BASENAME Override default value for BASENAME
2193 2193 BASH Override default value for BASH
2194 2194 CAT Override default value for CAT
2195 2195 CHMOD Override default value for CHMOD
2196 2196 CMP Override default value for CMP
2197 2197 COMM Override default value for COMM
2198 2198 CP Override default value for CP
2199 2199 CUT Override default value for CUT
2200 2200 DATE Override default value for DATE
2201 2201 DIFF Override default value for DIFF
2202 2202 DIRNAME Override default value for DIRNAME
2203 2203 ECHO Override default value for ECHO
2204 2204 EXPR Override default value for EXPR
2205 2205 FILE Override default value for FILE
2206 2206 FIND Override default value for FIND
2207 2207 HEAD Override default value for HEAD
2208 2208 GUNZIP Override default value for GUNZIP
2209 2209 GZIP Override default value for GZIP
2210 2210 LN Override default value for LN
2211 2211 LS Override default value for LS
2212 2212 MKDIR Override default value for MKDIR
2213 2213 MKTEMP Override default value for MKTEMP
2214 2214 MV Override default value for MV
2215 2215 NAWK Override default value for NAWK
2216 2216 PRINTF Override default value for PRINTF
2217 2217 RM Override default value for RM
2218 2218 RMDIR Override default value for RMDIR
2219 2219 SH Override default value for SH
2220 2220 SORT Override default value for SORT
2221 2221 TAIL Override default value for TAIL
2222 2222 TAR Override default value for TAR
2223 2223 TEE Override default value for TEE
2224 2224 TOUCH Override default value for TOUCH
2225 2225 TR Override default value for TR
2226 2226 UNAME Override default value for UNAME
2227 2227 UNIQ Override default value for UNIQ
2228 2228 WC Override default value for WC
2229 2229 WHICH Override default value for WHICH
2230 2230 XARGS Override default value for XARGS
2231 2231 AWK Override default value for AWK
2232 2232 GREP Override default value for GREP
2233 2233 EGREP Override default value for EGREP
2234 2234 FGREP Override default value for FGREP
2235 2235 SED Override default value for SED
2236 2236 CYGPATH Override default value for CYGPATH
2237 2237 READLINK Override default value for READLINK
2238 2238 DF Override default value for DF
2239 2239 CPIO Override default value for CPIO
2240 2240 NICE Override default value for NICE
2241 2241 MAKE Override default value for MAKE
2242 2242 UNZIP Override default value for UNZIP
2243 2243 ZIP Override default value for ZIP
2244 2244 LDD Override default value for LDD
2245 2245 OTOOL Override default value for OTOOL
2246 2246 READELF Override default value for READELF
2247 2247 HG Override default value for HG
2248 2248 STAT Override default value for STAT
2249 2249 TIME Override default value for TIME
2250 2250 DTRACE Override default value for DTRACE
2251 2251 PATCH Override default value for PATCH
2252 2252 DSYMUTIL Override default value for DSYMUTIL
2253 2253 XATTR Override default value for XATTR
2254 2254 CODESIGN Override default value for CODESIGN
2255 2255 SETFILE Override default value for SETFILE
2256 2256 PKG_CONFIG path to pkg-config utility
2257 2257 JAVA Override default value for JAVA
2258 2258 JAVAC Override default value for JAVAC
2259 2259 JAVAH Override default value for JAVAH
2260 2260 JAR Override default value for JAR
2261 2261 JARSIGNER Override default value for JARSIGNER
2262 2262 CC C compiler command
2263 2263 CFLAGS C compiler flags
2264 2264 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
2265 2265 nonstandard directory <lib dir>
2266 2266 LIBS libraries to pass to the linker, e.g. -l<library>
2267 2267 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2268 2268 you have headers in a nonstandard directory <include dir>
2269 2269 CXX C++ compiler command
2270 2270 CXXFLAGS C++ compiler flags
2271 2271 CPP C preprocessor
2272 2272 CXXCPP C++ preprocessor
2273 2273 AS Override default value for AS
2274 2274 AR Override default value for AR
2275 2275 LIPO Override default value for LIPO
2276 2276 STRIP Override default value for STRIP
2277 2277 NM Override default value for NM
2278 2278 GNM Override default value for GNM
2279 2279 OBJCOPY Override default value for OBJCOPY
2280 2280 OBJDUMP Override default value for OBJDUMP
2281 2281 BUILD_CC Override default value for BUILD_CC
2282 2282 BUILD_CXX Override default value for BUILD_CXX
2283 2283 BUILD_NM Override default value for BUILD_NM
2284 2284 BUILD_AR Override default value for BUILD_AR
2285 2285 BUILD_OBJCOPY
2286 2286 Override default value for BUILD_OBJCOPY
2287 2287 BUILD_STRIP Override default value for BUILD_STRIP
2288 2288 JTREGEXE Override default value for JTREGEXE
2289 2289 XMKMF Path to xmkmf, Makefile generator for X Window System
2290 2290 FREETYPE_CFLAGS
2291 2291 C compiler flags for FREETYPE, overriding pkg-config
2292 2292 FREETYPE_LIBS
2293 2293 linker flags for FREETYPE, overriding pkg-config
2294 2294 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2295 2295 ALSA_LIBS linker flags for ALSA, overriding pkg-config
2296 2296 LIBFFI_CFLAGS
2297 2297 C compiler flags for LIBFFI, overriding pkg-config
2298 2298 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2299 2299 PNG_CFLAGS C compiler flags for PNG, overriding pkg-config
2300 2300 PNG_LIBS linker flags for PNG, overriding pkg-config
2301 2301 LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2302 2302 LCMS_LIBS linker flags for LCMS, overriding pkg-config
2303 2303 ICECC_CMD Override default value for ICECC_CMD
2304 2304 ICECC_CREATE_ENV
2305 2305 Override default value for ICECC_CREATE_ENV
2306 2306 ICECC_WRAPPER
2307 2307 Override default value for ICECC_WRAPPER
2308 2308 CCACHE Override default value for CCACHE
2309 2309
2310 2310 Use these variables to override the choices made by `configure' or to help
2311 2311 it to find libraries and programs with nonstandard names/locations.
2312 2312
2313 2313 Report bugs to <build-dev@openjdk.java.net>.
2314 2314 OpenJDK home page: <http://openjdk.java.net>.
2315 2315 _ACEOF
2316 2316 ac_status=$?
2317 2317 fi
2318 2318
2319 2319 if test "$ac_init_help" = "recursive"; then
2320 2320 # If there are subdirs, report their specific --help.
2321 2321 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2322 2322 test -d "$ac_dir" ||
2323 2323 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2324 2324 continue
2325 2325 ac_builddir=.
2326 2326
2327 2327 case "$ac_dir" in
2328 2328 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2329 2329 *)
2330 2330 ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2331 2331 # A ".." for each directory in $ac_dir_suffix.
2332 2332 ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2333 2333 case $ac_top_builddir_sub in
2334 2334 "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2335 2335 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2336 2336 esac ;;
2337 2337 esac
2338 2338 ac_abs_top_builddir=$ac_pwd
2339 2339 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2340 2340 # for backward compatibility:
2341 2341 ac_top_builddir=$ac_top_build_prefix
2342 2342
2343 2343 case $srcdir in
2344 2344 .) # We are building in place.
2345 2345 ac_srcdir=.
2346 2346 ac_top_srcdir=$ac_top_builddir_sub
2347 2347 ac_abs_top_srcdir=$ac_pwd ;;
2348 2348 [\\/]* | ?:[\\/]* ) # Absolute name.
2349 2349 ac_srcdir=$srcdir$ac_dir_suffix;
2350 2350 ac_top_srcdir=$srcdir
2351 2351 ac_abs_top_srcdir=$srcdir ;;
2352 2352 *) # Relative name.
2353 2353 ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2354 2354 ac_top_srcdir=$ac_top_build_prefix$srcdir
2355 2355 ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2356 2356 esac
2357 2357 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2358 2358
2359 2359 cd "$ac_dir" || { ac_status=$?; continue; }
2360 2360 # Check for guested configure.
2361 2361 if test -f "$ac_srcdir/configure.gnu"; then
2362 2362 echo &&
2363 2363 $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2364 2364 elif test -f "$ac_srcdir/configure"; then
2365 2365 echo &&
2366 2366 $SHELL "$ac_srcdir/configure" --help=recursive
2367 2367 else
2368 2368 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2369 2369 fi || ac_status=$?
2370 2370 cd "$ac_pwd" || { ac_status=$?; break; }
2371 2371 done
2372 2372 fi
2373 2373
2374 2374 test -n "$ac_init_help" && exit $ac_status
2375 2375 if $ac_init_version; then
2376 2376 cat <<\_ACEOF
2377 2377 OpenJDK configure jdk9
2378 2378 generated by GNU Autoconf 2.69
2379 2379
2380 2380 Copyright (C) 2012 Free Software Foundation, Inc.
2381 2381 This configure script is free software; the Free Software Foundation
2382 2382 gives unlimited permission to copy, distribute and modify it.
2383 2383 _ACEOF
2384 2384 exit
2385 2385 fi
2386 2386
2387 2387 ## ------------------------ ##
2388 2388 ## Autoconf initialization. ##
2389 2389 ## ------------------------ ##
2390 2390
2391 2391 # ac_fn_c_try_compile LINENO
2392 2392 # --------------------------
2393 2393 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2394 2394 ac_fn_c_try_compile ()
2395 2395 {
2396 2396 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2397 2397 rm -f conftest.$ac_objext
2398 2398 if { { ac_try="$ac_compile"
2399 2399 case "(($ac_try" in
2400 2400 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2401 2401 *) ac_try_echo=$ac_try;;
2402 2402 esac
2403 2403 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2404 2404 $as_echo "$ac_try_echo"; } >&5
2405 2405 (eval "$ac_compile") 2>conftest.err
2406 2406 ac_status=$?
2407 2407 if test -s conftest.err; then
2408 2408 grep -v '^ *+' conftest.err >conftest.er1
2409 2409 cat conftest.er1 >&5
2410 2410 mv -f conftest.er1 conftest.err
2411 2411 fi
2412 2412 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2413 2413 test $ac_status = 0; } && {
2414 2414 test -z "$ac_c_werror_flag" ||
2415 2415 test ! -s conftest.err
2416 2416 } && test -s conftest.$ac_objext; then :
2417 2417 ac_retval=0
2418 2418 else
2419 2419 $as_echo "$as_me: failed program was:" >&5
2420 2420 sed 's/^/| /' conftest.$ac_ext >&5
2421 2421
2422 2422 ac_retval=1
2423 2423 fi
2424 2424 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2425 2425 as_fn_set_status $ac_retval
2426 2426
2427 2427 } # ac_fn_c_try_compile
2428 2428
2429 2429 # ac_fn_cxx_try_compile LINENO
2430 2430 # ----------------------------
2431 2431 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2432 2432 ac_fn_cxx_try_compile ()
2433 2433 {
2434 2434 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2435 2435 rm -f conftest.$ac_objext
2436 2436 if { { ac_try="$ac_compile"
2437 2437 case "(($ac_try" in
2438 2438 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2439 2439 *) ac_try_echo=$ac_try;;
2440 2440 esac
2441 2441 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2442 2442 $as_echo "$ac_try_echo"; } >&5
2443 2443 (eval "$ac_compile") 2>conftest.err
2444 2444 ac_status=$?
2445 2445 if test -s conftest.err; then
2446 2446 grep -v '^ *+' conftest.err >conftest.er1
2447 2447 cat conftest.er1 >&5
2448 2448 mv -f conftest.er1 conftest.err
2449 2449 fi
2450 2450 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2451 2451 test $ac_status = 0; } && {
2452 2452 test -z "$ac_cxx_werror_flag" ||
2453 2453 test ! -s conftest.err
2454 2454 } && test -s conftest.$ac_objext; then :
2455 2455 ac_retval=0
2456 2456 else
2457 2457 $as_echo "$as_me: failed program was:" >&5
2458 2458 sed 's/^/| /' conftest.$ac_ext >&5
2459 2459
2460 2460 ac_retval=1
2461 2461 fi
2462 2462 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2463 2463 as_fn_set_status $ac_retval
2464 2464
2465 2465 } # ac_fn_cxx_try_compile
2466 2466
2467 2467 # ac_fn_c_try_cpp LINENO
2468 2468 # ----------------------
2469 2469 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2470 2470 ac_fn_c_try_cpp ()
2471 2471 {
2472 2472 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2473 2473 if { { ac_try="$ac_cpp conftest.$ac_ext"
2474 2474 case "(($ac_try" in
2475 2475 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2476 2476 *) ac_try_echo=$ac_try;;
2477 2477 esac
2478 2478 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2479 2479 $as_echo "$ac_try_echo"; } >&5
2480 2480 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2481 2481 ac_status=$?
2482 2482 if test -s conftest.err; then
2483 2483 grep -v '^ *+' conftest.err >conftest.er1
2484 2484 cat conftest.er1 >&5
2485 2485 mv -f conftest.er1 conftest.err
2486 2486 fi
2487 2487 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2488 2488 test $ac_status = 0; } > conftest.i && {
2489 2489 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2490 2490 test ! -s conftest.err
2491 2491 }; then :
2492 2492 ac_retval=0
2493 2493 else
2494 2494 $as_echo "$as_me: failed program was:" >&5
2495 2495 sed 's/^/| /' conftest.$ac_ext >&5
2496 2496
2497 2497 ac_retval=1
2498 2498 fi
2499 2499 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2500 2500 as_fn_set_status $ac_retval
2501 2501
2502 2502 } # ac_fn_c_try_cpp
2503 2503
2504 2504 # ac_fn_cxx_try_cpp LINENO
2505 2505 # ------------------------
2506 2506 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2507 2507 ac_fn_cxx_try_cpp ()
2508 2508 {
2509 2509 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2510 2510 if { { ac_try="$ac_cpp conftest.$ac_ext"
2511 2511 case "(($ac_try" in
2512 2512 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2513 2513 *) ac_try_echo=$ac_try;;
2514 2514 esac
2515 2515 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2516 2516 $as_echo "$ac_try_echo"; } >&5
2517 2517 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2518 2518 ac_status=$?
2519 2519 if test -s conftest.err; then
2520 2520 grep -v '^ *+' conftest.err >conftest.er1
2521 2521 cat conftest.er1 >&5
2522 2522 mv -f conftest.er1 conftest.err
2523 2523 fi
2524 2524 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2525 2525 test $ac_status = 0; } > conftest.i && {
2526 2526 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2527 2527 test ! -s conftest.err
2528 2528 }; then :
2529 2529 ac_retval=0
2530 2530 else
2531 2531 $as_echo "$as_me: failed program was:" >&5
2532 2532 sed 's/^/| /' conftest.$ac_ext >&5
2533 2533
2534 2534 ac_retval=1
2535 2535 fi
2536 2536 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2537 2537 as_fn_set_status $ac_retval
2538 2538
2539 2539 } # ac_fn_cxx_try_cpp
2540 2540
2541 2541 # ac_fn_c_try_link LINENO
2542 2542 # -----------------------
2543 2543 # Try to link conftest.$ac_ext, and return whether this succeeded.
2544 2544 ac_fn_c_try_link ()
2545 2545 {
2546 2546 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2547 2547 rm -f conftest.$ac_objext conftest$ac_exeext
2548 2548 if { { ac_try="$ac_link"
2549 2549 case "(($ac_try" in
2550 2550 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2551 2551 *) ac_try_echo=$ac_try;;
2552 2552 esac
2553 2553 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2554 2554 $as_echo "$ac_try_echo"; } >&5
2555 2555 (eval "$ac_link") 2>conftest.err
2556 2556 ac_status=$?
2557 2557 if test -s conftest.err; then
2558 2558 grep -v '^ *+' conftest.err >conftest.er1
2559 2559 cat conftest.er1 >&5
2560 2560 mv -f conftest.er1 conftest.err
2561 2561 fi
2562 2562 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2563 2563 test $ac_status = 0; } && {
2564 2564 test -z "$ac_c_werror_flag" ||
2565 2565 test ! -s conftest.err
2566 2566 } && test -s conftest$ac_exeext && {
2567 2567 test "$cross_compiling" = yes ||
2568 2568 test -x conftest$ac_exeext
2569 2569 }; then :
2570 2570 ac_retval=0
2571 2571 else
2572 2572 $as_echo "$as_me: failed program was:" >&5
2573 2573 sed 's/^/| /' conftest.$ac_ext >&5
2574 2574
2575 2575 ac_retval=1
2576 2576 fi
2577 2577 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2578 2578 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2579 2579 # interfere with the next link command; also delete a directory that is
2580 2580 # left behind by Apple's compiler. We do this before executing the actions.
2581 2581 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2582 2582 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2583 2583 as_fn_set_status $ac_retval
2584 2584
2585 2585 } # ac_fn_c_try_link
2586 2586
2587 2587 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2588 2588 # ---------------------------------------------------------
2589 2589 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2590 2590 # the include files in INCLUDES and setting the cache variable VAR
2591 2591 # accordingly.
2592 2592 ac_fn_cxx_check_header_mongrel ()
2593 2593 {
2594 2594 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2595 2595 if eval \${$3+:} false; then :
2596 2596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2597 2597 $as_echo_n "checking for $2... " >&6; }
2598 2598 if eval \${$3+:} false; then :
2599 2599 $as_echo_n "(cached) " >&6
2600 2600 fi
2601 2601 eval ac_res=\$$3
2602 2602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2603 2603 $as_echo "$ac_res" >&6; }
2604 2604 else
2605 2605 # Is the header compilable?
2606 2606 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2607 2607 $as_echo_n "checking $2 usability... " >&6; }
2608 2608 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2609 2609 /* end confdefs.h. */
2610 2610 $4
2611 2611 #include <$2>
2612 2612 _ACEOF
2613 2613 if ac_fn_cxx_try_compile "$LINENO"; then :
2614 2614 ac_header_compiler=yes
2615 2615 else
2616 2616 ac_header_compiler=no
2617 2617 fi
2618 2618 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2619 2619 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2620 2620 $as_echo "$ac_header_compiler" >&6; }
2621 2621
2622 2622 # Is the header present?
2623 2623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2624 2624 $as_echo_n "checking $2 presence... " >&6; }
2625 2625 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2626 2626 /* end confdefs.h. */
2627 2627 #include <$2>
2628 2628 _ACEOF
2629 2629 if ac_fn_cxx_try_cpp "$LINENO"; then :
2630 2630 ac_header_preproc=yes
2631 2631 else
2632 2632 ac_header_preproc=no
2633 2633 fi
2634 2634 rm -f conftest.err conftest.i conftest.$ac_ext
2635 2635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2636 2636 $as_echo "$ac_header_preproc" >&6; }
2637 2637
2638 2638 # So? What about this header?
2639 2639 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2640 2640 yes:no: )
2641 2641 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2642 2642 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2643 2643 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2644 2644 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2645 2645 ;;
2646 2646 no:yes:* )
2647 2647 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2648 2648 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2649 2649 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
2650 2650 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
2651 2651 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2652 2652 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2653 2653 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
2654 2654 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
2655 2655 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2656 2656 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2657 2657 ( $as_echo "## ----------------------------------------- ##
2658 2658 ## Report this to build-dev@openjdk.java.net ##
2659 2659 ## ----------------------------------------- ##"
2660 2660 ) | sed "s/^/$as_me: WARNING: /" >&2
2661 2661 ;;
2662 2662 esac
2663 2663 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2664 2664 $as_echo_n "checking for $2... " >&6; }
2665 2665 if eval \${$3+:} false; then :
2666 2666 $as_echo_n "(cached) " >&6
2667 2667 else
2668 2668 eval "$3=\$ac_header_compiler"
2669 2669 fi
2670 2670 eval ac_res=\$$3
2671 2671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2672 2672 $as_echo "$ac_res" >&6; }
2673 2673 fi
2674 2674 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2675 2675
2676 2676 } # ac_fn_cxx_check_header_mongrel
2677 2677
2678 2678 # ac_fn_cxx_try_run LINENO
2679 2679 # ------------------------
2680 2680 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2681 2681 # that executables *can* be run.
2682 2682 ac_fn_cxx_try_run ()
2683 2683 {
2684 2684 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2685 2685 if { { ac_try="$ac_link"
2686 2686 case "(($ac_try" in
2687 2687 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2688 2688 *) ac_try_echo=$ac_try;;
2689 2689 esac
2690 2690 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2691 2691 $as_echo "$ac_try_echo"; } >&5
2692 2692 (eval "$ac_link") 2>&5
2693 2693 ac_status=$?
2694 2694 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2695 2695 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2696 2696 { { case "(($ac_try" in
2697 2697 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2698 2698 *) ac_try_echo=$ac_try;;
2699 2699 esac
2700 2700 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2701 2701 $as_echo "$ac_try_echo"; } >&5
2702 2702 (eval "$ac_try") 2>&5
2703 2703 ac_status=$?
2704 2704 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2705 2705 test $ac_status = 0; }; }; then :
2706 2706 ac_retval=0
2707 2707 else
2708 2708 $as_echo "$as_me: program exited with status $ac_status" >&5
2709 2709 $as_echo "$as_me: failed program was:" >&5
2710 2710 sed 's/^/| /' conftest.$ac_ext >&5
2711 2711
2712 2712 ac_retval=$ac_status
2713 2713 fi
2714 2714 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2715 2715 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2716 2716 as_fn_set_status $ac_retval
2717 2717
2718 2718 } # ac_fn_cxx_try_run
2719 2719
2720 2720 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2721 2721 # ---------------------------------------------------------
2722 2722 # Tests whether HEADER exists and can be compiled using the include files in
2723 2723 # INCLUDES, setting the cache variable VAR accordingly.
2724 2724 ac_fn_cxx_check_header_compile ()
2725 2725 {
2726 2726 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2727 2727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2728 2728 $as_echo_n "checking for $2... " >&6; }
2729 2729 if eval \${$3+:} false; then :
2730 2730 $as_echo_n "(cached) " >&6
2731 2731 else
2732 2732 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2733 2733 /* end confdefs.h. */
2734 2734 $4
2735 2735 #include <$2>
2736 2736 _ACEOF
2737 2737 if ac_fn_cxx_try_compile "$LINENO"; then :
2738 2738 eval "$3=yes"
2739 2739 else
2740 2740 eval "$3=no"
2741 2741 fi
2742 2742 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2743 2743 fi
2744 2744 eval ac_res=\$$3
2745 2745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2746 2746 $as_echo "$ac_res" >&6; }
2747 2747 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2748 2748
2749 2749 } # ac_fn_cxx_check_header_compile
2750 2750
2751 2751 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2752 2752 # ----------------------------------------------
2753 2753 # Tries to find the compile-time value of EXPR in a program that includes
2754 2754 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2755 2755 # computed
2756 2756 ac_fn_cxx_compute_int ()
2757 2757 {
2758 2758 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2759 2759 if test "$cross_compiling" = yes; then
2760 2760 # Depending upon the size, compute the lo and hi bounds.
2761 2761 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2762 2762 /* end confdefs.h. */
2763 2763 $4
2764 2764 int
2765 2765 main ()
2766 2766 {
2767 2767 static int test_array [1 - 2 * !(($2) >= 0)];
2768 2768 test_array [0] = 0;
2769 2769 return test_array [0];
2770 2770
2771 2771 ;
2772 2772 return 0;
2773 2773 }
2774 2774 _ACEOF
2775 2775 if ac_fn_cxx_try_compile "$LINENO"; then :
2776 2776 ac_lo=0 ac_mid=0
2777 2777 while :; do
2778 2778 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2779 2779 /* end confdefs.h. */
2780 2780 $4
2781 2781 int
2782 2782 main ()
2783 2783 {
2784 2784 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2785 2785 test_array [0] = 0;
2786 2786 return test_array [0];
2787 2787
2788 2788 ;
2789 2789 return 0;
2790 2790 }
2791 2791 _ACEOF
2792 2792 if ac_fn_cxx_try_compile "$LINENO"; then :
2793 2793 ac_hi=$ac_mid; break
2794 2794 else
2795 2795 as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2796 2796 if test $ac_lo -le $ac_mid; then
2797 2797 ac_lo= ac_hi=
2798 2798 break
2799 2799 fi
2800 2800 as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2801 2801 fi
2802 2802 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2803 2803 done
2804 2804 else
2805 2805 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2806 2806 /* end confdefs.h. */
2807 2807 $4
2808 2808 int
2809 2809 main ()
2810 2810 {
2811 2811 static int test_array [1 - 2 * !(($2) < 0)];
2812 2812 test_array [0] = 0;
2813 2813 return test_array [0];
2814 2814
2815 2815 ;
2816 2816 return 0;
2817 2817 }
2818 2818 _ACEOF
2819 2819 if ac_fn_cxx_try_compile "$LINENO"; then :
2820 2820 ac_hi=-1 ac_mid=-1
2821 2821 while :; do
2822 2822 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2823 2823 /* end confdefs.h. */
2824 2824 $4
2825 2825 int
2826 2826 main ()
2827 2827 {
2828 2828 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2829 2829 test_array [0] = 0;
2830 2830 return test_array [0];
2831 2831
2832 2832 ;
2833 2833 return 0;
2834 2834 }
2835 2835 _ACEOF
2836 2836 if ac_fn_cxx_try_compile "$LINENO"; then :
2837 2837 ac_lo=$ac_mid; break
2838 2838 else
2839 2839 as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2840 2840 if test $ac_mid -le $ac_hi; then
2841 2841 ac_lo= ac_hi=
2842 2842 break
2843 2843 fi
2844 2844 as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2845 2845 fi
2846 2846 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2847 2847 done
2848 2848 else
2849 2849 ac_lo= ac_hi=
2850 2850 fi
2851 2851 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2852 2852 fi
2853 2853 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2854 2854 # Binary search between lo and hi bounds.
2855 2855 while test "x$ac_lo" != "x$ac_hi"; do
2856 2856 as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2857 2857 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2858 2858 /* end confdefs.h. */
2859 2859 $4
2860 2860 int
2861 2861 main ()
2862 2862 {
2863 2863 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2864 2864 test_array [0] = 0;
2865 2865 return test_array [0];
2866 2866
2867 2867 ;
2868 2868 return 0;
2869 2869 }
2870 2870 _ACEOF
2871 2871 if ac_fn_cxx_try_compile "$LINENO"; then :
2872 2872 ac_hi=$ac_mid
2873 2873 else
2874 2874 as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2875 2875 fi
2876 2876 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2877 2877 done
2878 2878 case $ac_lo in #((
2879 2879 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2880 2880 '') ac_retval=1 ;;
2881 2881 esac
2882 2882 else
2883 2883 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2884 2884 /* end confdefs.h. */
2885 2885 $4
2886 2886 static long int longval () { return $2; }
2887 2887 static unsigned long int ulongval () { return $2; }
2888 2888 #include <stdio.h>
2889 2889 #include <stdlib.h>
2890 2890 int
2891 2891 main ()
2892 2892 {
2893 2893
2894 2894 FILE *f = fopen ("conftest.val", "w");
2895 2895 if (! f)
2896 2896 return 1;
2897 2897 if (($2) < 0)
2898 2898 {
2899 2899 long int i = longval ();
2900 2900 if (i != ($2))
2901 2901 return 1;
2902 2902 fprintf (f, "%ld", i);
2903 2903 }
2904 2904 else
2905 2905 {
2906 2906 unsigned long int i = ulongval ();
2907 2907 if (i != ($2))
2908 2908 return 1;
2909 2909 fprintf (f, "%lu", i);
2910 2910 }
2911 2911 /* Do not output a trailing newline, as this causes \r\n confusion
2912 2912 on some platforms. */
2913 2913 return ferror (f) || fclose (f) != 0;
2914 2914
2915 2915 ;
2916 2916 return 0;
2917 2917 }
2918 2918 _ACEOF
2919 2919 if ac_fn_cxx_try_run "$LINENO"; then :
2920 2920 echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2921 2921 else
2922 2922 ac_retval=1
2923 2923 fi
2924 2924 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2925 2925 conftest.$ac_objext conftest.beam conftest.$ac_ext
2926 2926 rm -f conftest.val
2927 2927
2928 2928 fi
2929 2929 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2930 2930 as_fn_set_status $ac_retval
2931 2931
2932 2932 } # ac_fn_cxx_compute_int
2933 2933
2934 2934 # ac_fn_cxx_try_link LINENO
2935 2935 # -------------------------
2936 2936 # Try to link conftest.$ac_ext, and return whether this succeeded.
2937 2937 ac_fn_cxx_try_link ()
2938 2938 {
2939 2939 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2940 2940 rm -f conftest.$ac_objext conftest$ac_exeext
2941 2941 if { { ac_try="$ac_link"
2942 2942 case "(($ac_try" in
2943 2943 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2944 2944 *) ac_try_echo=$ac_try;;
2945 2945 esac
2946 2946 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2947 2947 $as_echo "$ac_try_echo"; } >&5
2948 2948 (eval "$ac_link") 2>conftest.err
2949 2949 ac_status=$?
2950 2950 if test -s conftest.err; then
2951 2951 grep -v '^ *+' conftest.err >conftest.er1
2952 2952 cat conftest.er1 >&5
2953 2953 mv -f conftest.er1 conftest.err
2954 2954 fi
2955 2955 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2956 2956 test $ac_status = 0; } && {
2957 2957 test -z "$ac_cxx_werror_flag" ||
2958 2958 test ! -s conftest.err
2959 2959 } && test -s conftest$ac_exeext && {
2960 2960 test "$cross_compiling" = yes ||
2961 2961 test -x conftest$ac_exeext
2962 2962 }; then :
2963 2963 ac_retval=0
2964 2964 else
2965 2965 $as_echo "$as_me: failed program was:" >&5
2966 2966 sed 's/^/| /' conftest.$ac_ext >&5
2967 2967
2968 2968 ac_retval=1
2969 2969 fi
2970 2970 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2971 2971 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2972 2972 # interfere with the next link command; also delete a directory that is
2973 2973 # left behind by Apple's compiler. We do this before executing the actions.
2974 2974 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2975 2975 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2976 2976 as_fn_set_status $ac_retval
2977 2977
2978 2978 } # ac_fn_cxx_try_link
2979 2979
2980 2980 # ac_fn_cxx_check_func LINENO FUNC VAR
2981 2981 # ------------------------------------
2982 2982 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2983 2983 ac_fn_cxx_check_func ()
2984 2984 {
2985 2985 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2986 2986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2987 2987 $as_echo_n "checking for $2... " >&6; }
2988 2988 if eval \${$3+:} false; then :
2989 2989 $as_echo_n "(cached) " >&6
2990 2990 else
2991 2991 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2992 2992 /* end confdefs.h. */
2993 2993 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2994 2994 For example, HP-UX 11i <limits.h> declares gettimeofday. */
2995 2995 #define $2 innocuous_$2
2996 2996
2997 2997 /* System header to define __stub macros and hopefully few prototypes,
2998 2998 which can conflict with char $2 (); below.
2999 2999 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3000 3000 <limits.h> exists even on freestanding compilers. */
3001 3001
3002 3002 #ifdef __STDC__
3003 3003 # include <limits.h>
3004 3004 #else
3005 3005 # include <assert.h>
3006 3006 #endif
3007 3007
3008 3008 #undef $2
3009 3009
3010 3010 /* Override any GCC internal prototype to avoid an error.
3011 3011 Use char because int might match the return type of a GCC
3012 3012 builtin and then its argument prototype would still apply. */
3013 3013 #ifdef __cplusplus
3014 3014 extern "C"
3015 3015 #endif
3016 3016 char $2 ();
3017 3017 /* The GNU C library defines this for functions which it implements
3018 3018 to always fail with ENOSYS. Some functions are actually named
3019 3019 something starting with __ and the normal name is an alias. */
3020 3020 #if defined __stub_$2 || defined __stub___$2
3021 3021 choke me
3022 3022 #endif
3023 3023
3024 3024 int
3025 3025 main ()
3026 3026 {
3027 3027 return $2 ();
3028 3028 ;
3029 3029 return 0;
3030 3030 }
3031 3031 _ACEOF
3032 3032 if ac_fn_cxx_try_link "$LINENO"; then :
3033 3033 eval "$3=yes"
3034 3034 else
3035 3035 eval "$3=no"
3036 3036 fi
3037 3037 rm -f core conftest.err conftest.$ac_objext \
3038 3038 conftest$ac_exeext conftest.$ac_ext
3039 3039 fi
3040 3040 eval ac_res=\$$3
3041 3041 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3042 3042 $as_echo "$ac_res" >&6; }
3043 3043 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3044 3044
3045 3045 } # ac_fn_cxx_check_func
3046 3046
3047 3047 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
3048 3048 # -------------------------------------------------------
3049 3049 # Tests whether HEADER exists and can be compiled using the include files in
3050 3050 # INCLUDES, setting the cache variable VAR accordingly.
3051 3051 ac_fn_c_check_header_compile ()
3052 3052 {
3053 3053 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
3054 3054 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
3055 3055 $as_echo_n "checking for $2... " >&6; }
3056 3056 if eval \${$3+:} false; then :
3057 3057 $as_echo_n "(cached) " >&6
3058 3058 else
3059 3059 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3060 3060 /* end confdefs.h. */
3061 3061 $4
3062 3062 #include <$2>
3063 3063 _ACEOF
3064 3064 if ac_fn_c_try_compile "$LINENO"; then :
3065 3065 eval "$3=yes"
3066 3066 else
3067 3067 eval "$3=no"
3068 3068 fi
3069 3069 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3070 3070 fi
3071 3071 eval ac_res=\$$3
3072 3072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3073 3073 $as_echo "$ac_res" >&6; }
3074 3074 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3075 3075
3076 3076 } # ac_fn_c_check_header_compile
3077 3077 cat >config.log <<_ACEOF
3078 3078 This file contains any messages produced by compilers while
3079 3079 running configure, to aid debugging if configure makes a mistake.
3080 3080
3081 3081 It was created by OpenJDK $as_me jdk9, which was
3082 3082 generated by GNU Autoconf 2.69. Invocation command line was
3083 3083
3084 3084 $ $0 $@
3085 3085
3086 3086 _ACEOF
3087 3087 exec 5>>config.log
3088 3088 {
3089 3089 cat <<_ASUNAME
3090 3090 ## --------- ##
3091 3091 ## Platform. ##
3092 3092 ## --------- ##
3093 3093
3094 3094 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
3095 3095 uname -m = `(uname -m) 2>/dev/null || echo unknown`
3096 3096 uname -r = `(uname -r) 2>/dev/null || echo unknown`
3097 3097 uname -s = `(uname -s) 2>/dev/null || echo unknown`
3098 3098 uname -v = `(uname -v) 2>/dev/null || echo unknown`
3099 3099
3100 3100 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
3101 3101 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
3102 3102
3103 3103 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
3104 3104 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
3105 3105 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
3106 3106 /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
3107 3107 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
3108 3108 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
3109 3109 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
3110 3110
3111 3111 _ASUNAME
3112 3112
3113 3113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3114 3114 for as_dir in $PATH
3115 3115 do
3116 3116 IFS=$as_save_IFS
3117 3117 test -z "$as_dir" && as_dir=.
3118 3118 $as_echo "PATH: $as_dir"
3119 3119 done
3120 3120 IFS=$as_save_IFS
3121 3121
3122 3122 } >&5
3123 3123
3124 3124 cat >&5 <<_ACEOF
3125 3125
3126 3126
3127 3127 ## ----------- ##
3128 3128 ## Core tests. ##
3129 3129 ## ----------- ##
3130 3130
3131 3131 _ACEOF
3132 3132
3133 3133
3134 3134 # Keep a trace of the command line.
3135 3135 # Strip out --no-create and --no-recursion so they do not pile up.
3136 3136 # Strip out --silent because we don't want to record it for future runs.
3137 3137 # Also quote any args containing shell meta-characters.
3138 3138 # Make two passes to allow for proper duplicate-argument suppression.
3139 3139 ac_configure_args=
3140 3140 ac_configure_args0=
3141 3141 ac_configure_args1=
3142 3142 ac_must_keep_next=false
3143 3143 for ac_pass in 1 2
3144 3144 do
3145 3145 for ac_arg
3146 3146 do
3147 3147 case $ac_arg in
3148 3148 -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3149 3149 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3150 3150 | -silent | --silent | --silen | --sile | --sil)
3151 3151 continue ;;
3152 3152 *\'*)
3153 3153 ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3154 3154 esac
3155 3155 case $ac_pass in
3156 3156 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3157 3157 2)
3158 3158 as_fn_append ac_configure_args1 " '$ac_arg'"
3159 3159 if test $ac_must_keep_next = true; then
3160 3160 ac_must_keep_next=false # Got value, back to normal.
3161 3161 else
3162 3162 case $ac_arg in
3163 3163 *=* | --config-cache | -C | -disable-* | --disable-* \
3164 3164 | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3165 3165 | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3166 3166 | -with-* | --with-* | -without-* | --without-* | --x)
3167 3167 case "$ac_configure_args0 " in
3168 3168 "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3169 3169 esac
3170 3170 ;;
3171 3171 -* ) ac_must_keep_next=true ;;
3172 3172 esac
3173 3173 fi
3174 3174 as_fn_append ac_configure_args " '$ac_arg'"
3175 3175 ;;
3176 3176 esac
3177 3177 done
3178 3178 done
3179 3179 { ac_configure_args0=; unset ac_configure_args0;}
3180 3180 { ac_configure_args1=; unset ac_configure_args1;}
3181 3181
3182 3182 # When interrupted or exit'd, cleanup temporary files, and complete
3183 3183 # config.log. We remove comments because anyway the quotes in there
3184 3184 # would cause problems or look ugly.
3185 3185 # WARNING: Use '\'' to represent an apostrophe within the trap.
3186 3186 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3187 3187 trap 'exit_status=$?
3188 3188 # Save into config.log some information that might help in debugging.
3189 3189 {
3190 3190 echo
3191 3191
3192 3192 $as_echo "## ---------------- ##
3193 3193 ## Cache variables. ##
3194 3194 ## ---------------- ##"
3195 3195 echo
3196 3196 # The following way of writing the cache mishandles newlines in values,
3197 3197 (
3198 3198 for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3199 3199 eval ac_val=\$$ac_var
3200 3200 case $ac_val in #(
3201 3201 *${as_nl}*)
3202 3202 case $ac_var in #(
3203 3203 *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3204 3204 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3205 3205 esac
3206 3206 case $ac_var in #(
3207 3207 _ | IFS | as_nl) ;; #(
3208 3208 BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3209 3209 *) { eval $ac_var=; unset $ac_var;} ;;
3210 3210 esac ;;
3211 3211 esac
3212 3212 done
3213 3213 (set) 2>&1 |
3214 3214 case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3215 3215 *${as_nl}ac_space=\ *)
3216 3216 sed -n \
3217 3217 "s/'\''/'\''\\\\'\'''\''/g;
3218 3218 s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3219 3219 ;; #(
3220 3220 *)
3221 3221 sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3222 3222 ;;
3223 3223 esac |
3224 3224 sort
3225 3225 )
3226 3226 echo
3227 3227
3228 3228 $as_echo "## ----------------- ##
3229 3229 ## Output variables. ##
3230 3230 ## ----------------- ##"
3231 3231 echo
3232 3232 for ac_var in $ac_subst_vars
3233 3233 do
3234 3234 eval ac_val=\$$ac_var
3235 3235 case $ac_val in
3236 3236 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3237 3237 esac
3238 3238 $as_echo "$ac_var='\''$ac_val'\''"
3239 3239 done | sort
3240 3240 echo
3241 3241
3242 3242 if test -n "$ac_subst_files"; then
3243 3243 $as_echo "## ------------------- ##
3244 3244 ## File substitutions. ##
3245 3245 ## ------------------- ##"
3246 3246 echo
3247 3247 for ac_var in $ac_subst_files
3248 3248 do
3249 3249 eval ac_val=\$$ac_var
3250 3250 case $ac_val in
3251 3251 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3252 3252 esac
3253 3253 $as_echo "$ac_var='\''$ac_val'\''"
3254 3254 done | sort
3255 3255 echo
3256 3256 fi
3257 3257
3258 3258 if test -s confdefs.h; then
3259 3259 $as_echo "## ----------- ##
3260 3260 ## confdefs.h. ##
3261 3261 ## ----------- ##"
3262 3262 echo
3263 3263 cat confdefs.h
3264 3264 echo
3265 3265 fi
3266 3266 test "$ac_signal" != 0 &&
3267 3267 $as_echo "$as_me: caught signal $ac_signal"
3268 3268 $as_echo "$as_me: exit $exit_status"
3269 3269 } >&5
3270 3270 rm -f core *.core core.conftest.* &&
3271 3271 rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3272 3272 exit $exit_status
3273 3273 ' 0
3274 3274 for ac_signal in 1 2 13 15; do
3275 3275 trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3276 3276 done
3277 3277 ac_signal=0
3278 3278
3279 3279 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3280 3280 rm -f -r conftest* confdefs.h
3281 3281
3282 3282 $as_echo "/* confdefs.h */" > confdefs.h
3283 3283
3284 3284 # Predefined preprocessor variables.
3285 3285
3286 3286 cat >>confdefs.h <<_ACEOF
3287 3287 #define PACKAGE_NAME "$PACKAGE_NAME"
3288 3288 _ACEOF
3289 3289
3290 3290 cat >>confdefs.h <<_ACEOF
3291 3291 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3292 3292 _ACEOF
3293 3293
3294 3294 cat >>confdefs.h <<_ACEOF
3295 3295 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3296 3296 _ACEOF
3297 3297
3298 3298 cat >>confdefs.h <<_ACEOF
3299 3299 #define PACKAGE_STRING "$PACKAGE_STRING"
3300 3300 _ACEOF
3301 3301
3302 3302 cat >>confdefs.h <<_ACEOF
3303 3303 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3304 3304 _ACEOF
3305 3305
3306 3306 cat >>confdefs.h <<_ACEOF
3307 3307 #define PACKAGE_URL "$PACKAGE_URL"
3308 3308 _ACEOF
3309 3309
3310 3310
3311 3311 # Let the site file select an alternate cache file if it wants to.
3312 3312 # Prefer an explicitly selected file to automatically selected ones.
3313 3313 ac_site_file1=NONE
3314 3314 ac_site_file2=NONE
3315 3315 if test -n "$CONFIG_SITE"; then
3316 3316 # We do not want a PATH search for config.site.
3317 3317 case $CONFIG_SITE in #((
3318 3318 -*) ac_site_file1=./$CONFIG_SITE;;
3319 3319 */*) ac_site_file1=$CONFIG_SITE;;
3320 3320 *) ac_site_file1=./$CONFIG_SITE;;
3321 3321 esac
3322 3322 elif test "x$prefix" != xNONE; then
3323 3323 ac_site_file1=$prefix/share/config.site
3324 3324 ac_site_file2=$prefix/etc/config.site
3325 3325 else
3326 3326 ac_site_file1=$ac_default_prefix/share/config.site
3327 3327 ac_site_file2=$ac_default_prefix/etc/config.site
3328 3328 fi
3329 3329 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3330 3330 do
3331 3331 test "x$ac_site_file" = xNONE && continue
3332 3332 if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3333 3333 { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3334 3334 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3335 3335 sed 's/^/| /' "$ac_site_file" >&5
3336 3336 . "$ac_site_file" \
3337 3337 || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3338 3338 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3339 3339 as_fn_error $? "failed to load site script $ac_site_file
3340 3340 See \`config.log' for more details" "$LINENO" 5; }
3341 3341 fi
3342 3342 done
3343 3343
3344 3344 if test -r "$cache_file"; then
3345 3345 # Some versions of bash will fail to source /dev/null (special files
3346 3346 # actually), so we avoid doing that. DJGPP emulates it as a regular file.
3347 3347 if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3348 3348 { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3349 3349 $as_echo "$as_me: loading cache $cache_file" >&6;}
3350 3350 case $cache_file in
3351 3351 [\\/]* | ?:[\\/]* ) . "$cache_file";;
3352 3352 *) . "./$cache_file";;
3353 3353 esac
3354 3354 fi
3355 3355 else
3356 3356 { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3357 3357 $as_echo "$as_me: creating cache $cache_file" >&6;}
3358 3358 >$cache_file
3359 3359 fi
3360 3360
3361 3361 # Check that the precious variables saved in the cache have kept the same
3362 3362 # value.
3363 3363 ac_cache_corrupted=false
3364 3364 for ac_var in $ac_precious_vars; do
3365 3365 eval ac_old_set=\$ac_cv_env_${ac_var}_set
3366 3366 eval ac_new_set=\$ac_env_${ac_var}_set
3367 3367 eval ac_old_val=\$ac_cv_env_${ac_var}_value
3368 3368 eval ac_new_val=\$ac_env_${ac_var}_value
3369 3369 case $ac_old_set,$ac_new_set in
3370 3370 set,)
3371 3371 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3372 3372 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3373 3373 ac_cache_corrupted=: ;;
3374 3374 ,set)
3375 3375 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3376 3376 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3377 3377 ac_cache_corrupted=: ;;
3378 3378 ,);;
3379 3379 *)
3380 3380 if test "x$ac_old_val" != "x$ac_new_val"; then
3381 3381 # differences in whitespace do not lead to failure.
3382 3382 ac_old_val_w=`echo x $ac_old_val`
3383 3383 ac_new_val_w=`echo x $ac_new_val`
3384 3384 if test "$ac_old_val_w" != "$ac_new_val_w"; then
3385 3385 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3386 3386 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3387 3387 ac_cache_corrupted=:
3388 3388 else
3389 3389 { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3390 3390 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3391 3391 eval $ac_var=\$ac_old_val
3392 3392 fi
3393 3393 { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
3394 3394 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
3395 3395 { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
3396 3396 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
3397 3397 fi;;
3398 3398 esac
3399 3399 # Pass precious variables to config.status.
3400 3400 if test "$ac_new_set" = set; then
3401 3401 case $ac_new_val in
3402 3402 *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3403 3403 *) ac_arg=$ac_var=$ac_new_val ;;
3404 3404 esac
3405 3405 case " $ac_configure_args " in
3406 3406 *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
3407 3407 *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3408 3408 esac
3409 3409 fi
3410 3410 done
3411 3411 if $ac_cache_corrupted; then
3412 3412 { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3413 3413 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3414 3414 { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3415 3415 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3416 3416 as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3417 3417 fi
3418 3418 ## -------------------- ##
3419 3419 ## Main body of script. ##
3420 3420 ## -------------------- ##
3421 3421
3422 3422 ac_ext=c
3423 3423 ac_cpp='$CPP $CPPFLAGS'
3424 3424 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3425 3425 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3426 3426 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3427 3427
3428 3428
3429 3429
3430 3430 ac_aux_dir=
3431 3431 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3432 3432 if test -f "$ac_dir/install-sh"; then
3433 3433 ac_aux_dir=$ac_dir
3434 3434 ac_install_sh="$ac_aux_dir/install-sh -c"
3435 3435 break
3436 3436 elif test -f "$ac_dir/install.sh"; then
3437 3437 ac_aux_dir=$ac_dir
3438 3438 ac_install_sh="$ac_aux_dir/install.sh -c"
3439 3439 break
3440 3440 elif test -f "$ac_dir/shtool"; then
3441 3441 ac_aux_dir=$ac_dir
3442 3442 ac_install_sh="$ac_aux_dir/shtool install -c"
3443 3443 break
3444 3444 fi
3445 3445 done
3446 3446 if test -z "$ac_aux_dir"; then
3447 3447 as_fn_error $? "cannot find install-sh, install.sh, or shtool in $TOPDIR/common/autoconf/build-aux \"$srcdir\"/$TOPDIR/common/autoconf/build-aux" "$LINENO" 5
3448 3448 fi
3449 3449
3450 3450 # These three variables are undocumented and unsupported,
3451 3451 # and are intended to be withdrawn in a future Autoconf release.
3452 3452 # They can cause serious problems if a builder's source tree is in a directory
3453 3453 # whose full name contains unusual characters.
3454 3454 ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
3455 3455 ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
3456 3456 ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
3457 3457
3458 3458
3459 3459 # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
3460 3460
3461 3461 #
3462 3462 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3463 3463 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3464 3464 #
3465 3465 # This code is free software; you can redistribute it and/or modify it
3466 3466 # under the terms of the GNU General Public License version 2 only, as
3467 3467 # published by the Free Software Foundation. Oracle designates this
3468 3468 # particular file as subject to the "Classpath" exception as provided
3469 3469 # by Oracle in the LICENSE file that accompanied this code.
3470 3470 #
3471 3471 # This code is distributed in the hope that it will be useful, but WITHOUT
3472 3472 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3473 3473 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3474 3474 # version 2 for more details (a copy is included in the LICENSE file that
3475 3475 # accompanied this code).
3476 3476 #
3477 3477 # You should have received a copy of the GNU General Public License version
3478 3478 # 2 along with this work; if not, write to the Free Software Foundation,
3479 3479 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3480 3480 #
3481 3481 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3482 3482 # or visit www.oracle.com if you need additional information or have any
3483 3483 # questions.
3484 3484 #
3485 3485
3486 3486 #
3487 3487 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3488 3488 #
3489 3489 # This program is free software; you can redistribute it and/or modify
3490 3490 # it under the terms of the GNU General Public License as published by
3491 3491 # the Free Software Foundation; either version 2 of the License, or
3492 3492 # (at your option) any later version.
3493 3493 #
3494 3494 # This program is distributed in the hope that it will be useful, but
3495 3495 # WITHOUT ANY WARRANTY; without even the implied warranty of
3496 3496 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3497 3497 # General Public License for more details.
3498 3498 #
3499 3499 # You should have received a copy of the GNU General Public License
3500 3500 # along with this program; if not, write to the Free Software
3501 3501 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3502 3502 #
3503 3503 # As a special exception to the GNU General Public License, if you
3504 3504 # distribute this file as part of a program that contains a
3505 3505 # configuration script generated by Autoconf, you may include it under
3506 3506 # the same distribution terms that you use for the rest of that program.
3507 3507
3508 3508 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3509 3509 # ----------------------------------
3510 3510 # PKG_PROG_PKG_CONFIG
3511 3511
3512 3512 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3513 3513 #
3514 3514 # Check to see whether a particular set of modules exists. Similar
3515 3515 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3516 3516 #
3517 3517 #
3518 3518 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3519 3519 # this or PKG_CHECK_MODULES is called, or make sure to call
3520 3520 # PKG_CHECK_EXISTS manually
3521 3521 # --------------------------------------------------------------
3522 3522
3523 3523
3524 3524
3525 3525 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3526 3526 # ---------------------------------------------
3527 3527 # _PKG_CONFIG
3528 3528
3529 3529 # _PKG_SHORT_ERRORS_SUPPORTED
3530 3530 # -----------------------------
3531 3531 # _PKG_SHORT_ERRORS_SUPPORTED
3532 3532
3533 3533
3534 3534 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3535 3535 # [ACTION-IF-NOT-FOUND])
3536 3536 #
3537 3537 #
3538 3538 # Note that if there is a possibility the first call to
3539 3539 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3540 3540 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3541 3541 #
3542 3542 #
3543 3543 # --------------------------------------------------------------
3544 3544 # PKG_CHECK_MODULES
3545 3545
3546 3546
3547 3547 # Include these first...
3548 3548 #
3549 3549 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3550 3550 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3551 3551 #
3552 3552 # This code is free software; you can redistribute it and/or modify it
3553 3553 # under the terms of the GNU General Public License version 2 only, as
3554 3554 # published by the Free Software Foundation. Oracle designates this
3555 3555 # particular file as subject to the "Classpath" exception as provided
3556 3556 # by Oracle in the LICENSE file that accompanied this code.
3557 3557 #
3558 3558 # This code is distributed in the hope that it will be useful, but WITHOUT
3559 3559 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3560 3560 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3561 3561 # version 2 for more details (a copy is included in the LICENSE file that
3562 3562 # accompanied this code).
3563 3563 #
3564 3564 # You should have received a copy of the GNU General Public License version
3565 3565 # 2 along with this work; if not, write to the Free Software Foundation,
3566 3566 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3567 3567 #
3568 3568 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3569 3569 # or visit www.oracle.com if you need additional information or have any
3570 3570 # questions.
3571 3571 #
3572 3572
3573 3573 # Create a function/macro that takes a series of named arguments. The call is
3574 3574 # similar to AC_DEFUN, but the setup of the function looks like this:
3575 3575 # BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
3576 3576 # ... do something
3577 3577 # AC_MSG_NOTICE([Value of BAR is ARG_BAR])
3578 3578 # ])
3579 3579 # A star (*) in front of a named argument means that it is required and it's
3580 3580 # presence will be verified. To pass e.g. the first value as a normal indexed
3581 3581 # argument, use [m4_shift($@)] as the third argument instead of [$@]. These
3582 3582 # arguments are referenced in the function by their name prefixed by ARG_, e.g.
3583 3583 # "ARG_FOO".
3584 3584 #
3585 3585 # The generated function can be called like this:
3586 3586 # MYFUNC(FOO: [foo-val],
3587 3587 # BAR: [
3588 3588 # $ECHO hello world
3589 3589 # ])
3590 3590 # Note that the argument value must start on the same line as the argument name.
3591 3591 #
3592 3592 # Argument 1: Name of the function to define
3593 3593 # Argument 2: List of legal named arguments, with a * prefix for required arguments
3594 3594 # Argument 3: Argument array to treat as named, typically $@
3595 3595 # Argument 4: The main function body
3596 3596
3597 3597
3598 3598 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3599 3599 # If so, then append $1 to $2 \
3600 3600 # Also set JVM_ARG_OK to true/false depending on outcome.
3601 3601
3602 3602
3603 3603 # Appends a string to a path variable, only adding the : when needed.
3604 3604
3605 3605
3606 3606 # Prepends a string to a path variable, only adding the : when needed.
3607 3607
3608 3608
3609 3609 # This will make sure the given variable points to a full and proper
3610 3610 # path. This means:
3611 3611 # 1) There will be no spaces in the path. On unix platforms,
3612 3612 # spaces in the path will result in an error. On Windows,
3613 3613 # the path will be rewritten using short-style to be space-free.
3614 3614 # 2) The path will be absolute, and it will be in unix-style (on
3615 3615 # cygwin).
3616 3616 # $1: The name of the variable to fix
3617 3617
3618 3618
3619 3619 # This will make sure the given variable points to a executable
3620 3620 # with a full and proper path. This means:
3621 3621 # 1) There will be no spaces in the path. On unix platforms,
3622 3622 # spaces in the path will result in an error. On Windows,
3623 3623 # the path will be rewritten using short-style to be space-free.
3624 3624 # 2) The path will be absolute, and it will be in unix-style (on
3625 3625 # cygwin).
3626 3626 # Any arguments given to the executable is preserved.
3627 3627 # If the input variable does not have a directory specification, then
3628 3628 # it need to be in the PATH.
3629 3629 # $1: The name of the variable to fix
3630 3630
3631 3631
3632 3632
3633 3633
3634 3634 # Register a --with argument but mark it as deprecated
3635 3635 # $1: The name of the with argument to deprecate, not including --with-
3636 3636
3637 3637
3638 3638 # Register a --enable argument but mark it as deprecated
3639 3639 # $1: The name of the with argument to deprecate, not including --enable-
3640 3640 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3641 3641 # $3: Messages to user.
3642 3642
3643 3643
3644 3644
3645 3645
3646 3646 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3647 3647 # $1: variable to check
3648 3648
3649 3649
3650 3650 # Check that there are no unprocessed overridden variables left.
3651 3651 # If so, they are an incorrect argument and we will exit with an error.
3652 3652
3653 3653
3654 3654 # Setup a tool for the given variable. If correctly specified by the user,
3655 3655 # use that value, otherwise search for the tool using the supplied code snippet.
3656 3656 # $1: variable to set
3657 3657 # $2: code snippet to call to look for the tool
3658 3658 # $3: code snippet to call if variable was used to find tool
3659 3659
3660 3660
3661 3661 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3662 3662 # $1: variable to set
3663 3663 # $2: executable name (or list of names) to look for
3664 3664
3665 3665
3666 3666 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3667 3667 # $1: variable to set
3668 3668 # $2: executable name (or list of names) to look for
3669 3669
3670 3670
3671 3671 # Like BASIC_PATH_PROGS but fails if no tool was found.
3672 3672 # $1: variable to set
3673 3673 # $2: executable name (or list of names) to look for
3674 3674
3675 3675
3676 3676 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3677 3677 # $1: variable to set
3678 3678 # $2: autoconf macro to call to look for the special tool
3679 3679
3680 3680
3681 3681 # Setup the most fundamental tools that relies on not much else to set up,
3682 3682 # but is used by much of the early bootstrap code.
3683 3683
3684 3684
3685 3685 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3686 3686
3687 3687
3688 3688 # Evaluates platform specific overrides for devkit variables.
3689 3689 # $1: Name of variable
3690 3690
3691 3691
3692 3692
3693 3693
3694 3694
3695 3695
3696 3696 #%%% Simple tools %%%
3697 3697
3698 3698 # Check if we have found a usable version of make
3699 3699 # $1: the path to a potential make binary (or empty)
3700 3700 # $2: the description on how we found this
3701 3701
3702 3702
3703 3703
3704 3704
3705 3705 # Goes looking for a usable version of GNU make.
3706 3706
3707 3707
3708 3708
3709 3709
3710 3710
3711 3711
3712 3712
3713 3713
3714 3714 # Check if build directory is on local disk. If not possible to determine,
3715 3715 # we prefer to claim it's local.
3716 3716 # Argument 1: directory to test
3717 3717 # Argument 2: what to do if it is on local disk
3718 3718 # Argument 3: what to do otherwise (remote disk or failure)
3719 3719
3720 3720
3721 3721 # Check that source files have basic read permissions set. This might
3722 3722 # not be the case in cygwin in certain conditions.
3723 3723
3724 3724
3725 3725
3726 3726
3727 3727 # Check for support for specific options in bash
3728 3728
3729 3729
3730 3730 ################################################################################
3731 3731 #
3732 3732 # Default make target
3733 3733 #
3734 3734
3735 3735
3736 3736 # Code to run after AC_OUTPUT
3737 3737
3738 3738
3739 3739 #
3740 3740 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3741 3741 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3742 3742 #
3743 3743 # This code is free software; you can redistribute it and/or modify it
3744 3744 # under the terms of the GNU General Public License version 2 only, as
3745 3745 # published by the Free Software Foundation. Oracle designates this
3746 3746 # particular file as subject to the "Classpath" exception as provided
3747 3747 # by Oracle in the LICENSE file that accompanied this code.
3748 3748 #
3749 3749 # This code is distributed in the hope that it will be useful, but WITHOUT
3750 3750 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3751 3751 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3752 3752 # version 2 for more details (a copy is included in the LICENSE file that
3753 3753 # accompanied this code).
3754 3754 #
3755 3755 # You should have received a copy of the GNU General Public License version
3756 3756 # 2 along with this work; if not, write to the Free Software Foundation,
3757 3757 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3758 3758 #
3759 3759 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3760 3760 # or visit www.oracle.com if you need additional information or have any
3761 3761 # questions.
3762 3762 #
3763 3763
3764 3764
3765 3765
3766 3766
3767 3767
3768 3768 # Helper function which possibly converts a path using DOS-style short mode.
3769 3769 # If so, the updated path is stored in $new_path.
3770 3770 # $1: The path to check
3771 3771
3772 3772
3773 3773 # Helper function which possibly converts a path using DOS-style short mode.
3774 3774 # If so, the updated path is stored in $new_path.
3775 3775 # $1: The path to check
3776 3776
3777 3777
3778 3778 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3779 3779 # and could probably be heavily simplified. However, all changes in this
3780 3780 # area tend to need lot of testing in different scenarios, and in lack of
3781 3781 # proper unit testing, cleaning this up has not been deemed worth the effort
3782 3782 # at the moment.
3783 3783
3784 3784
3785 3785
3786 3786
3787 3787
3788 3788
3789 3789
3790 3790
3791 3791
3792 3792 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3793 3793
3794 3794
3795 3795
3796 3796
3797 3797 # ... then the rest
3798 3798 #
3799 3799 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3800 3800 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3801 3801 #
3802 3802 # This code is free software; you can redistribute it and/or modify it
3803 3803 # under the terms of the GNU General Public License version 2 only, as
3804 3804 # published by the Free Software Foundation. Oracle designates this
3805 3805 # particular file as subject to the "Classpath" exception as provided
3806 3806 # by Oracle in the LICENSE file that accompanied this code.
3807 3807 #
3808 3808 # This code is distributed in the hope that it will be useful, but WITHOUT
3809 3809 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3810 3810 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3811 3811 # version 2 for more details (a copy is included in the LICENSE file that
3812 3812 # accompanied this code).
3813 3813 #
3814 3814 # You should have received a copy of the GNU General Public License version
3815 3815 # 2 along with this work; if not, write to the Free Software Foundation,
3816 3816 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3817 3817 #
3818 3818 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3819 3819 # or visit www.oracle.com if you need additional information or have any
3820 3820 # questions.
3821 3821 #
3822 3822
3823 3823 ########################################################################
3824 3824 # This file handles detection of the Boot JDK. The Boot JDK detection
3825 3825 # process has been developed as a response to solve a complex real-world
3826 3826 # problem. Initially, it was simple, but it has grown as platform after
3827 3827 # platform, idiosyncracy after idiosyncracy has been supported.
3828 3828 #
3829 3829 # The basic idea is this:
3830 3830 # 1) You need an acceptable *) JDK to use as a Boot JDK
3831 3831 # 2) There are several ways to locate a JDK, that are mostly platform
3832 3832 # dependent **)
3833 3833 # 3) You can have multiple JDKs installed
3834 3834 # 4) If possible, configure should try to dig out an acceptable JDK
3835 3835 # automatically, without having to resort to command-line options
3836 3836 #
3837 3837 # *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3838 3838 # javac) and not a JRE, etc.
3839 3839 #
3840 3840 # **) On Windows we typically use a well-known path.
3841 3841 # On MacOSX we typically use the tool java_home.
3842 3842 # On Linux we typically find javac in the $PATH, and then follow a
3843 3843 # chain of symlinks that often ends up in a real JDK.
3844 3844 #
3845 3845 # This leads to the code where we check in different ways to locate a
3846 3846 # JDK, and if one is found, check if it is acceptable. If not, we print
3847 3847 # our reasons for rejecting it (useful when debugging non-working
3848 3848 # configure situations) and continue checking the next one.
3849 3849 ########################################################################
3850 3850
3851 3851 # Execute the check given as argument, and verify the result
3852 3852 # If the Boot JDK was previously found, do nothing
3853 3853 # $1 A command line (typically autoconf macro) to execute
3854 3854
3855 3855
3856 3856 # Test: Is bootjdk explicitely set by command line arguments?
3857 3857
3858 3858
3859 3859 # Test: Is $JAVA_HOME set?
3860 3860
3861 3861
3862 3862 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3863 3863
3864 3864
3865 3865 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3866 3866 # $1: Argument to the java_home binary (optional)
3867 3867
3868 3868
3869 3869 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3870 3870
3871 3871
3872 3872 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3873 3873 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3874 3874 # $1 = Path to directory containing jdk installations.
3875 3875 # $2 = String to append to the found JDK directory to get the proper JDK home
3876 3876
3877 3877
3878 3878 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3879 3879 # environmental variable as base for where to look.
3880 3880 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3881 3881
3882 3882
3883 3883 # Test: Is there a JDK installed in default, well-known locations?
3884 3884
3885 3885
3886 3886 # Check that a command-line tool in the Boot JDK is correct
3887 3887 # $1 = name of variable to assign
3888 3888 # $2 = name of binary
3889 3889
3890 3890
3891 3891 ###############################################################################
3892 3892 #
3893 3893 # We need a Boot JDK to bootstrap the build.
3894 3894 #
3895 3895
3896 3896
3897 3897
3898 3898
3899 3899
3900 3900 # BUILD_JDK: the location of the latest JDK that can run
3901 3901 # on the host system and supports the target class file version
3902 3902 # generated in this JDK build. This variable should only be
3903 3903 # used after the launchers are built.
3904 3904 #
3905 3905
3906 3906 # Execute the check given as argument, and verify the result.
3907 3907 # If the JDK was previously found, do nothing.
3908 3908 # $1 A command line (typically autoconf macro) to execute
3909 3909
3910 3910
3911 3911 # By default the BUILD_JDK is the JDK_OUTPUTDIR. If the target architecture
3912 3912 # is different than the host system doing the build (e.g. cross-compilation),
3913 3913 # a special BUILD_JDK is built as part of the build process. An external
3914 3914 # prebuilt BUILD_JDK can also be supplied.
3915 3915
3916 3916
3917 3917 #
3918 3918 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3919 3919 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3920 3920 #
3921 3921 # This code is free software; you can redistribute it and/or modify it
3922 3922 # under the terms of the GNU General Public License version 2 only, as
3923 3923 # published by the Free Software Foundation. Oracle designates this
3924 3924 # particular file as subject to the "Classpath" exception as provided
3925 3925 # by Oracle in the LICENSE file that accompanied this code.
3926 3926 #
3927 3927 # This code is distributed in the hope that it will be useful, but WITHOUT
3928 3928 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3929 3929 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3930 3930 # version 2 for more details (a copy is included in the LICENSE file that
3931 3931 # accompanied this code).
3932 3932 #
3933 3933 # You should have received a copy of the GNU General Public License version
3934 3934 # 2 along with this work; if not, write to the Free Software Foundation,
3935 3935 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3936 3936 #
3937 3937 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3938 3938 # or visit www.oracle.com if you need additional information or have any
3939 3939 # questions.
3940 3940 #
3941 3941
3942 3942
3943 3943
3944 3944
3945 3945
3946 3946
3947 3947
3948 3948
3949 3949
3950 3950
3951 3951
3952 3952
3953 3953
3954 3954
3955 3955
3956 3956
3957 3957
3958 3958 ################################################################################
3959 3959 #
3960 3960 # Runs icecc-create-env once and prints the error if it fails
3961 3961 #
3962 3962 # $1: arguments to icecc-create-env
3963 3963 # $2: log file
3964 3964 #
3965 3965
3966 3966
3967 3967 ################################################################################
3968 3968 #
3969 3969 # Optionally enable distributed compilation of native code using icecc/icecream
3970 3970 #
3971 3971
3972 3972
3973 3973
3974 3974
3975 3975
3976 3976
3977 3977
3978 3978 #
3979 3979 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3980 3980 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3981 3981 #
3982 3982 # This code is free software; you can redistribute it and/or modify it
3983 3983 # under the terms of the GNU General Public License version 2 only, as
3984 3984 # published by the Free Software Foundation. Oracle designates this
3985 3985 # particular file as subject to the "Classpath" exception as provided
3986 3986 # by Oracle in the LICENSE file that accompanied this code.
3987 3987 #
3988 3988 # This code is distributed in the hope that it will be useful, but WITHOUT
3989 3989 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3990 3990 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3991 3991 # version 2 for more details (a copy is included in the LICENSE file that
3992 3992 # accompanied this code).
3993 3993 #
3994 3994 # You should have received a copy of the GNU General Public License version
3995 3995 # 2 along with this work; if not, write to the Free Software Foundation,
3996 3996 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3997 3997 #
3998 3998 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3999 3999 # or visit www.oracle.com if you need additional information or have any
4000 4000 # questions.
4001 4001 #
4002 4002
4003 4003 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
4004 4004 # corresponding configure arguments instead
4005 4005
4006 4006
4007 4007 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
4008 4008 # that configure can use them while detecting compilers.
4009 4009 # TOOLCHAIN_TYPE is available here.
4010 4010 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
4011 4011
4012 4012
4013 4013
4014 4014
4015 4015
4016 4016
4017 4017 # Documentation on common flags used for solstudio in HIGHEST.
4018 4018 #
4019 4019 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
4020 4020 # done with care, there are some assumptions below that need to
4021 4021 # be understood about the use of pointers, and IEEE behavior.
4022 4022 #
4023 4023 # -fns: Use non-standard floating point mode (not IEEE 754)
4024 4024 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
4025 4025 # -fsingle: Use single precision floating point with 'float'
4026 4026 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
4027 4027 # (Source with excessing pointer casting and data access with mixed
4028 4028 # pointer types are not recommended)
4029 4029 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
4030 4030 # (If you expect perfect errno behavior, do not use this)
4031 4031 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
4032 4032 # -xrestrict: Pointer parameters to functions do not overlap
4033 4033 # (Similar to -xalias_level=basic usage, but less obvious sometimes.
4034 4034 # If you pass in multiple pointers to the same data, do not use this)
4035 4035 # -xlibmil: Inline some library routines
4036 4036 # (If you expect perfect errno behavior, do not use this)
4037 4037 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
4038 4038 # (If you expect perfect errno behavior, do not use this)
4039 4039 # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
4040 4040
4041 4041 # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
4042 4042 # Bug?
4043 4043 #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
4044 4044 # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
4045 4045 # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
4046 4046 #fi
4047 4047
4048 4048
4049 4049
4050 4050
4051 4051
4052 4052
4053 4053 ################################################################################
4054 4054 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
4055 4055 # conditionals against.
4056 4056 # $2 - Optional prefix for each variable defined.
4057 4057
4058 4058
4059 4059 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4060 4060 # IF_FALSE: [RUN-IF-FALSE])
4061 4061 # ------------------------------------------------------------
4062 4062 # Check that the C compiler supports an argument
4063 4063
4064 4064
4065 4065
4066 4066
4067 4067 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4068 4068 # IF_FALSE: [RUN-IF-FALSE])
4069 4069 # ------------------------------------------------------------
4070 4070 # Check that the C++ compiler supports an argument
4071 4071
4072 4072
4073 4073
4074 4074
4075 4075 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4076 4076 # IF_FALSE: [RUN-IF-FALSE])
4077 4077 # ------------------------------------------------------------
4078 4078 # Check that the C and C++ compilers support an argument
4079 4079
4080 4080
4081 4081
4082 4082
4083 4083 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4084 4084 # IF_FALSE: [RUN-IF-FALSE])
4085 4085 # ------------------------------------------------------------
4086 4086 # Check that the linker support an argument
4087 4087
4088 4088
4089 4089
4090 4090
4091 4091
4092 4092
4093 4093 # FLAGS_SETUP_GCC6_COMPILER_FLAGS([PREFIX])
4094 4094 # Arguments:
4095 4095 # $1 - Optional prefix for each variable defined.
4096 4096
4097 4097
4098 4098 #
4099 4099 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4100 4100 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4101 4101 #
4102 4102 # This code is free software; you can redistribute it and/or modify it
4103 4103 # under the terms of the GNU General Public License version 2 only, as
4104 4104 # published by the Free Software Foundation. Oracle designates this
4105 4105 # particular file as subject to the "Classpath" exception as provided
4106 4106 # by Oracle in the LICENSE file that accompanied this code.
4107 4107 #
4108 4108 # This code is distributed in the hope that it will be useful, but WITHOUT
4109 4109 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4110 4110 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4111 4111 # version 2 for more details (a copy is included in the LICENSE file that
4112 4112 # accompanied this code).
4113 4113 #
4114 4114 # You should have received a copy of the GNU General Public License version
4115 4115 # 2 along with this work; if not, write to the Free Software Foundation,
4116 4116 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4117 4117 #
4118 4118 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4119 4119 # or visit www.oracle.com if you need additional information or have any
4120 4120 # questions.
4121 4121 #
4122 4122
4123 4123
4124 4124
4125 4125
4126 4126
4127 4127 cygwin_help() {
4128 4128 case $1 in
4129 4129 unzip)
4130 4130 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
4131 4131 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4132 4132 ;;
4133 4133 zip)
4134 4134 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
4135 4135 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4136 4136 ;;
4137 4137 make)
4138 4138 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
4139 4139 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4140 4140 ;;
4141 4141 freetype)
4142 4142 HELP_MSG="
4143 4143 The freetype library can now be build during the configure process.
4144 4144 Download the freetype sources and unpack them into an arbitrary directory:
4145 4145
4146 4146 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
4147 4147 tar -xzf freetype-2.5.3.tar.gz
4148 4148
4149 4149 Then run configure with '--with-freetype-src=<freetype_src>'. This will
4150 4150 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
4151 4151 builds or into '<freetype_src>/lib32' for 32-bit builds.
4152 4152 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
4153 4153 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
4154 4154
4155 4155 Alternatively you can unpack the sources like this to use the default directory:
4156 4156
4157 4157 tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
4158 4158 ;;
4159 4159 esac
4160 4160 }
4161 4161
4162 4162 msys_help() {
4163 4163 PKGHANDLER_COMMAND=""
4164 4164 }
4165 4165
4166 4166 apt_help() {
4167 4167 case $1 in
4168 4168 reduced)
4169 4169 PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
4170 4170 devkit)
4171 4171 PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
4172 4172 openjdk)
4173 4173 PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
4174 4174 alsa)
4175 4175 PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
4176 4176 cups)
4177 4177 PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
4178 4178 freetype)
4179 4179 PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
4180 4180 ffi)
4181 4181 PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
4182 4182 x11)
4183 4183 PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
4184 4184 ccache)
4185 4185 PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
4186 4186 dtrace)
4187 4187 PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
4188 4188 esac
4189 4189 }
4190 4190
4191 4191 yum_help() {
4192 4192 case $1 in
4193 4193 devkit)
4194 4194 PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
4195 4195 openjdk)
4196 4196 PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
4197 4197 alsa)
4198 4198 PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
4199 4199 cups)
4200 4200 PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
4201 4201 freetype)
4202 4202 PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
4203 4203 x11)
4204 4204 PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
4205 4205 ccache)
4206 4206 PKGHANDLER_COMMAND="sudo yum install ccache" ;;
4207 4207 esac
4208 4208 }
4209 4209
4210 4210 port_help() {
4211 4211 PKGHANDLER_COMMAND=""
4212 4212 }
4213 4213
4214 4214 pkgutil_help() {
4215 4215 PKGHANDLER_COMMAND=""
4216 4216 }
4217 4217
4218 4218 pkgadd_help() {
4219 4219 PKGHANDLER_COMMAND=""
4220 4220 }
4221 4221
4222 4222 # This function will check if we're called from the "configure" wrapper while
4223 4223 # printing --help. If so, we will print out additional information that can
4224 4224 # only be extracted within the autoconf script, and then exit. This must be
4225 4225 # called at the very beginning in configure.ac.
4226 4226
4227 4227
4228 4228
4229 4229
4230 4230
4231 4231
4232 4232 #
4233 4233 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4234 4234 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4235 4235 #
4236 4236 # This code is free software; you can redistribute it and/or modify it
4237 4237 # under the terms of the GNU General Public License version 2 only, as
4238 4238 # published by the Free Software Foundation. Oracle designates this
4239 4239 # particular file as subject to the "Classpath" exception as provided
4240 4240 # by Oracle in the LICENSE file that accompanied this code.
4241 4241 #
4242 4242 # This code is distributed in the hope that it will be useful, but WITHOUT
4243 4243 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4244 4244 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4245 4245 # version 2 for more details (a copy is included in the LICENSE file that
4246 4246 # accompanied this code).
4247 4247 #
4248 4248 # You should have received a copy of the GNU General Public License version
4249 4249 # 2 along with this work; if not, write to the Free Software Foundation,
4250 4250 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4251 4251 #
4252 4252 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4253 4253 # or visit www.oracle.com if you need additional information or have any
4254 4254 # questions.
4255 4255 #
4256 4256
4257 4257 # All valid JVM features, regardless of platform
4258 4258 VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
4259 4259 fprof vm-structs jni-check services management all-gcs nmt cds static-build"
4260 4260
4261 4261 # All valid JVM variants
4262 4262 VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
4263 4263
4264 4264 ###############################################################################
4265 4265 # Check if the specified JVM variant should be built. To be used in shell if
4266 4266 # constructs, like this:
4267 4267 # if HOTSPOT_CHECK_JVM_VARIANT(server); then
4268 4268 #
4269 4269 # Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
4270 4270
4271 4271 # Definition kept in one line to allow inlining in if statements.
4272 4272 # Additional [] needed to keep m4 from mangling shell constructs.
4273 4273
4274 4274
4275 4275 ###############################################################################
4276 4276 # Check if the specified JVM features are explicitly enabled. To be used in
4277 4277 # shell if constructs, like this:
4278 4278 # if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
4279 4279 #
4280 4280 # Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
4281 4281
4282 4282 # Definition kept in one line to allow inlining in if statements.
4283 4283 # Additional [] needed to keep m4 from mangling shell constructs.
4284 4284
4285 4285
4286 4286 ###############################################################################
4287 4287 # Check which variants of the JVM that we want to build. Available variants are:
4288 4288 # server: normal interpreter, and a tiered C1/C2 compiler
4289 4289 # client: normal interpreter, and C1 (no C2 compiler)
4290 4290 # minimal: reduced form of client with optional features stripped out
4291 4291 # core: normal interpreter only, no compiler
4292 4292 # zero: C++ based interpreter only, no compiler
4293 4293 # zeroshark: C++ based interpreter, and a llvm-based compiler
4294 4294 # custom: baseline JVM with no default features
4295 4295 #
4296 4296
4297 4297
4298 4298 ###############################################################################
4299 4299 # Check if dtrace should be enabled and has all prerequisites present.
4300 4300 #
4301 4301
4302 4302
4303 4303 ###############################################################################
4304 4304 # Set up all JVM features for each JVM variant.
4305 4305 #
4306 4306
4307 4307
4308 4308 ###############################################################################
4309 4309 # Validate JVM features once all setup is complete, including custom setup.
4310 4310 #
4311 4311
4312 4312
4313 4313 ################################################################################
4314 4314 # Check if gtest should be built
4315 4315 #
4316 4316
4317 4317
4318 4318 #
4319 4319 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4320 4320 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4321 4321 #
4322 4322 # This code is free software; you can redistribute it and/or modify it
4323 4323 # under the terms of the GNU General Public License version 2 only, as
4324 4324 # published by the Free Software Foundation. Oracle designates this
4325 4325 # particular file as subject to the "Classpath" exception as provided
4326 4326 # by Oracle in the LICENSE file that accompanied this code.
4327 4327 #
4328 4328 # This code is distributed in the hope that it will be useful, but WITHOUT
4329 4329 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4330 4330 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4331 4331 # version 2 for more details (a copy is included in the LICENSE file that
4332 4332 # accompanied this code).
4333 4333 #
4334 4334 # You should have received a copy of the GNU General Public License version
4335 4335 # 2 along with this work; if not, write to the Free Software Foundation,
4336 4336 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4337 4337 #
4338 4338 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4339 4339 # or visit www.oracle.com if you need additional information or have any
4340 4340 # questions.
4341 4341 #
4342 4342
4343 4343 ###############################################################################
4344 4344 # Check which variant of the JDK that we want to build.
4345 4345 # Currently we have:
4346 4346 # normal: standard edition
4347 4347 # but the custom make system may add other variants
4348 4348 #
4349 4349 # Effectively the JDK variant gives a name to a specific set of
4350 4350 # modules to compile into the JDK.
4351 4351
4352 4352
4353 4353 ###############################################################################
4354 4354 # Set the debug level
4355 4355 # release: no debug information, all optimizations, no asserts.
4356 4356 # optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
4357 4357 # fastdebug: debug information (-g), all optimizations, all asserts
4358 4358 # slowdebug: debug information (-g), no optimizations, all asserts
4359 4359
4360 4360
4361 4361 ###############################################################################
4362 4362 #
4363 4363 # Should we build only OpenJDK even if closed sources are present?
4364 4364 #
4365 4365
4366 4366
4367 4367
4368 4368
4369 4369 ###############################################################################
4370 4370 #
4371 4371 # Enable or disable the elliptic curve crypto implementation
4372 4372 #
4373 4373
4374 4374
4375 4375
4376 4376
4377 4377 ################################################################################
4378 4378 #
4379 4379 # Gcov coverage data for hotspot
4380 4380 #
4381 4381
4382 4382
4383 4383 ################################################################################
4384 4384 #
4385 4385 # Static build support. When enabled will generate static
4386 4386 # libraries instead of shared libraries for all JDK libs.
4387 4387 #
4388 4388
4389 4389
4390 4390 ################################################################################
4391 4391 #
4392 4392 # jlink options.
4393 4393 # We always keep packaged modules in JDK image.
4394 4394 #
4395 4395
4396 4396
4397 4397 ################################################################################
4398 4398 #
4399 4399 # Check if building of the jtreg failure handler should be enabled.
4400 4400 #
4401 4401
4402 4402
4403 4403 ################################################################################
4404 4404 #
4405 4405 # Enable or disable generation of the classlist at build time
4406 4406 #
4407 4407
4408 4408
4409 4409 #
4410 4410 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4411 4411 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4412 4412 #
4413 4413 # This code is free software; you can redistribute it and/or modify it
4414 4414 # under the terms of the GNU General Public License version 2 only, as
4415 4415 # published by the Free Software Foundation. Oracle designates this
4416 4416 # particular file as subject to the "Classpath" exception as provided
4417 4417 # by Oracle in the LICENSE file that accompanied this code.
4418 4418 #
4419 4419 # This code is distributed in the hope that it will be useful, but WITHOUT
4420 4420 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4421 4421 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4422 4422 # version 2 for more details (a copy is included in the LICENSE file that
4423 4423 # accompanied this code).
4424 4424 #
4425 4425 # You should have received a copy of the GNU General Public License version
4426 4426 # 2 along with this work; if not, write to the Free Software Foundation,
4427 4427 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4428 4428 #
4429 4429 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4430 4430 # or visit www.oracle.com if you need additional information or have any
4431 4431 # questions.
4432 4432 #
4433 4433
4434 4434 ###############################################################################
4435 4435 #
4436 4436 # Setup version numbers
4437 4437 #
4438 4438
4439 4439 # Verify that a given string represents a valid version number, and assign it
4440 4440 # to a variable.
4441 4441
4442 4442 # Argument 1: the variable to assign to
4443 4443 # Argument 2: the value given by the user
4444 4444
4445 4445
4446 4446
4447 4447
4448 4448 #
4449 4449 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4450 4450 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4451 4451 #
4452 4452 # This code is free software; you can redistribute it and/or modify it
4453 4453 # under the terms of the GNU General Public License version 2 only, as
4454 4454 # published by the Free Software Foundation. Oracle designates this
4455 4455 # particular file as subject to the "Classpath" exception as provided
4456 4456 # by Oracle in the LICENSE file that accompanied this code.
4457 4457 #
4458 4458 # This code is distributed in the hope that it will be useful, but WITHOUT
4459 4459 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4460 4460 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4461 4461 # version 2 for more details (a copy is included in the LICENSE file that
4462 4462 # accompanied this code).
4463 4463 #
4464 4464 # You should have received a copy of the GNU General Public License version
4465 4465 # 2 along with this work; if not, write to the Free Software Foundation,
4466 4466 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4467 4467 #
4468 4468 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4469 4469 # or visit www.oracle.com if you need additional information or have any
4470 4470 # questions.
4471 4471 #
4472 4472
4473 4473 # Major library component reside in separate files.
4474 4474 #
4475 4475 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4476 4476 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4477 4477 #
4478 4478 # This code is free software; you can redistribute it and/or modify it
4479 4479 # under the terms of the GNU General Public License version 2 only, as
4480 4480 # published by the Free Software Foundation. Oracle designates this
4481 4481 # particular file as subject to the "Classpath" exception as provided
4482 4482 # by Oracle in the LICENSE file that accompanied this code.
4483 4483 #
4484 4484 # This code is distributed in the hope that it will be useful, but WITHOUT
4485 4485 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4486 4486 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4487 4487 # version 2 for more details (a copy is included in the LICENSE file that
4488 4488 # accompanied this code).
4489 4489 #
4490 4490 # You should have received a copy of the GNU General Public License version
4491 4491 # 2 along with this work; if not, write to the Free Software Foundation,
4492 4492 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4493 4493 #
4494 4494 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4495 4495 # or visit www.oracle.com if you need additional information or have any
4496 4496 # questions.
4497 4497 #
4498 4498
4499 4499 ################################################################################
4500 4500 # Setup alsa (Advanced Linux Sound Architecture)
4501 4501 ################################################################################
4502 4502
4503 4503
4504 4504 #
4505 4505 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4506 4506 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4507 4507 #
4508 4508 # This code is free software; you can redistribute it and/or modify it
4509 4509 # under the terms of the GNU General Public License version 2 only, as
4510 4510 # published by the Free Software Foundation. Oracle designates this
4511 4511 # particular file as subject to the "Classpath" exception as provided
4512 4512 # by Oracle in the LICENSE file that accompanied this code.
4513 4513 #
4514 4514 # This code is distributed in the hope that it will be useful, but WITHOUT
4515 4515 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4516 4516 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4517 4517 # version 2 for more details (a copy is included in the LICENSE file that
4518 4518 # accompanied this code).
4519 4519 #
4520 4520 # You should have received a copy of the GNU General Public License version
4521 4521 # 2 along with this work; if not, write to the Free Software Foundation,
4522 4522 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4523 4523 #
4524 4524 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4525 4525 # or visit www.oracle.com if you need additional information or have any
4526 4526 # questions.
4527 4527 #
4528 4528
4529 4529 ################################################################################
4530 4530 # Setup bundled libraries.
4531 4531 #
4532 4532 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4533 4533 # OpenJDK repository. Default is to use these libraries as bundled, but they
4534 4534 # might be replaced by en external version by the user.
4535 4535 ################################################################################
4536 4536
4537 4537
4538 4538 ################################################################################
4539 4539 # Setup libjpeg
4540 4540 ################################################################################
4541 4541
4542 4542
4543 4543 ################################################################################
4544 4544 # Setup giflib
4545 4545 ################################################################################
4546 4546
4547 4547
4548 4548 ################################################################################
4549 4549 # Setup libpng
4550 4550 ################################################################################
4551 4551
4552 4552
4553 4553 ################################################################################
4554 4554 # Setup zlib
4555 4555 ################################################################################
4556 4556
4557 4557
4558 4558 ################################################################################
4559 4559 # Setup lcms (Little CMS)
4560 4560 ################################################################################
4561 4561
4562 4562
4563 4563 #
4564 4564 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4565 4565 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4566 4566 #
4567 4567 # This code is free software; you can redistribute it and/or modify it
4568 4568 # under the terms of the GNU General Public License version 2 only, as
4569 4569 # published by the Free Software Foundation. Oracle designates this
4570 4570 # particular file as subject to the "Classpath" exception as provided
4571 4571 # by Oracle in the LICENSE file that accompanied this code.
4572 4572 #
4573 4573 # This code is distributed in the hope that it will be useful, but WITHOUT
4574 4574 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4575 4575 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4576 4576 # version 2 for more details (a copy is included in the LICENSE file that
4577 4577 # accompanied this code).
4578 4578 #
4579 4579 # You should have received a copy of the GNU General Public License version
4580 4580 # 2 along with this work; if not, write to the Free Software Foundation,
4581 4581 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4582 4582 #
4583 4583 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4584 4584 # or visit www.oracle.com if you need additional information or have any
4585 4585 # questions.
4586 4586 #
4587 4587
4588 4588 ################################################################################
4589 4589 # Setup cups (Common Unix Printing System)
4590 4590 ################################################################################
4591 4591
4592 4592
4593 4593 #
4594 4594 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4595 4595 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4596 4596 #
4597 4597 # This code is free software; you can redistribute it and/or modify it
4598 4598 # under the terms of the GNU General Public License version 2 only, as
4599 4599 # published by the Free Software Foundation. Oracle designates this
4600 4600 # particular file as subject to the "Classpath" exception as provided
4601 4601 # by Oracle in the LICENSE file that accompanied this code.
4602 4602 #
4603 4603 # This code is distributed in the hope that it will be useful, but WITHOUT
4604 4604 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4605 4605 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4606 4606 # version 2 for more details (a copy is included in the LICENSE file that
4607 4607 # accompanied this code).
4608 4608 #
4609 4609 # You should have received a copy of the GNU General Public License version
4610 4610 # 2 along with this work; if not, write to the Free Software Foundation,
4611 4611 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4612 4612 #
4613 4613 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4614 4614 # or visit www.oracle.com if you need additional information or have any
4615 4615 # questions.
4616 4616 #
4617 4617
4618 4618 ################################################################################
4619 4619 # Setup libffi (Foreign Function Interface)
4620 4620 ################################################################################
4621 4621
4622 4622
4623 4623 #
4624 4624 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4625 4625 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4626 4626 #
4627 4627 # This code is free software; you can redistribute it and/or modify it
4628 4628 # under the terms of the GNU General Public License version 2 only, as
4629 4629 # published by the Free Software Foundation. Oracle designates this
4630 4630 # particular file as subject to the "Classpath" exception as provided
4631 4631 # by Oracle in the LICENSE file that accompanied this code.
4632 4632 #
4633 4633 # This code is distributed in the hope that it will be useful, but WITHOUT
4634 4634 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4635 4635 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4636 4636 # version 2 for more details (a copy is included in the LICENSE file that
4637 4637 # accompanied this code).
4638 4638 #
4639 4639 # You should have received a copy of the GNU General Public License version
4640 4640 # 2 along with this work; if not, write to the Free Software Foundation,
4641 4641 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4642 4642 #
4643 4643 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4644 4644 # or visit www.oracle.com if you need additional information or have any
4645 4645 # questions.
4646 4646 #
4647 4647
4648 4648 ################################################################################
4649 4649 # Build the freetype lib from source
4650 4650 ################################################################################
4651 4651
4652 4652
4653 4653 ################################################################################
4654 4654 # Check if a potential freeype library match is correct and usable
4655 4655 ################################################################################
4656 4656
4657 4657
4658 4658 ################################################################################
4659 4659 # Setup freetype (The FreeType2 font rendering library)
4660 4660 ################################################################################
4661 4661
4662 4662
4663 4663 #
4664 4664 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4665 4665 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4666 4666 #
4667 4667 # This code is free software; you can redistribute it and/or modify it
4668 4668 # under the terms of the GNU General Public License version 2 only, as
4669 4669 # published by the Free Software Foundation. Oracle designates this
4670 4670 # particular file as subject to the "Classpath" exception as provided
4671 4671 # by Oracle in the LICENSE file that accompanied this code.
4672 4672 #
4673 4673 # This code is distributed in the hope that it will be useful, but WITHOUT
4674 4674 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4675 4675 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4676 4676 # version 2 for more details (a copy is included in the LICENSE file that
4677 4677 # accompanied this code).
4678 4678 #
4679 4679 # You should have received a copy of the GNU General Public License version
4680 4680 # 2 along with this work; if not, write to the Free Software Foundation,
4681 4681 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4682 4682 #
4683 4683 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4684 4684 # or visit www.oracle.com if you need additional information or have any
4685 4685 # questions.
4686 4686 #
4687 4687
4688 4688 ################################################################################
4689 4689 # Setup the standard C/C++ runtime libraries.
4690 4690 #
4691 4691 # Most importantly, determine if stdc++ should be linked statically or
4692 4692 # dynamically.
4693 4693 ################################################################################
4694 4694
4695 4695
4696 4696 #
4697 4697 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4698 4698 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4699 4699 #
4700 4700 # This code is free software; you can redistribute it and/or modify it
4701 4701 # under the terms of the GNU General Public License version 2 only, as
4702 4702 # published by the Free Software Foundation. Oracle designates this
4703 4703 # particular file as subject to the "Classpath" exception as provided
4704 4704 # by Oracle in the LICENSE file that accompanied this code.
4705 4705 #
4706 4706 # This code is distributed in the hope that it will be useful, but WITHOUT
4707 4707 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4708 4708 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4709 4709 # version 2 for more details (a copy is included in the LICENSE file that
4710 4710 # accompanied this code).
4711 4711 #
4712 4712 # You should have received a copy of the GNU General Public License version
4713 4713 # 2 along with this work; if not, write to the Free Software Foundation,
4714 4714 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4715 4715 #
4716 4716 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4717 4717 # or visit www.oracle.com if you need additional information or have any
4718 4718 # questions.
4719 4719 #
4720 4720
4721 4721 ################################################################################
4722 4722 # Setup X11 Windows system
4723 4723 ################################################################################
4724 4724
4725 4725
4726 4726
4727 4727 ################################################################################
4728 4728 # Determine which libraries are needed for this configuration
4729 4729 ################################################################################
4730 4730
4731 4731
4732 4732 ################################################################################
4733 4733 # Parse library options, and setup needed libraries
4734 4734 ################################################################################
4735 4735
4736 4736
4737 4737 ################################################################################
4738 4738 # Setup llvm (Low-Level VM)
4739 4739 ################################################################################
4740 4740
4741 4741
4742 4742 ################################################################################
4743 4743 # Setup various libraries, typically small system libraries
4744 4744 ################################################################################
4745 4745
4746 4746
4747 4747 ################################################################################
4748 4748 # libstlport.so.1 is needed for running gtest on Solaris. Find it to
4749 4749 # redistribute it in the test image.
4750 4750 ################################################################################
4751 4751
4752 4752
4753 4753
4754 4754 #
4755 4755 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4756 4756 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4757 4757 #
4758 4758 # This code is free software; you can redistribute it and/or modify it
4759 4759 # under the terms of the GNU General Public License version 2 only, as
4760 4760 # published by the Free Software Foundation. Oracle designates this
4761 4761 # particular file as subject to the "Classpath" exception as provided
4762 4762 # by Oracle in the LICENSE file that accompanied this code.
4763 4763 #
4764 4764 # This code is distributed in the hope that it will be useful, but WITHOUT
4765 4765 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4766 4766 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4767 4767 # version 2 for more details (a copy is included in the LICENSE file that
4768 4768 # accompanied this code).
4769 4769 #
4770 4770 # You should have received a copy of the GNU General Public License version
4771 4771 # 2 along with this work; if not, write to the Free Software Foundation,
4772 4772 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4773 4773 #
4774 4774 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4775 4775 # or visit www.oracle.com if you need additional information or have any
4776 4776 # questions.
4777 4777 #
4778 4778
4779 4779 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4780 4780 # Converts autoconf style CPU name to OpenJDK style, into
4781 4781 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4782 4782
4783 4783
4784 4784 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4785 4785 # Converts autoconf style OS name to OpenJDK style, into
4786 4786 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4787 4787
4788 4788
4789 4789 # Expects $host_os $host_cpu $build_os and $build_cpu
4790 4790 # and $with_target_bits to have been setup!
4791 4791 #
4792 4792 # Translate the standard triplet(quadruplet) definition
4793 4793 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4794 4794 # OPENJDK_BUILD_OS, etc.
4795 4795
4796 4796
4797 4797 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4798 4798 # accordingly. Must be done after setting up build and target system, but before
4799 4799 # doing anything else with these values.
4800 4800
4801 4801
4802 4802 # Setup the legacy variables, for controlling the old makefiles.
4803 4803 #
4804 4804
4805 4805
4806 4806 # $1 - Either TARGET or BUILD to setup the variables for.
4807 4807
4808 4808
4809 4809
4810 4810
4811 4811 #%%% Build and target systems %%%
4812 4812
4813 4813
4814 4814
4815 4815
4816 4816 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4817 4817 # Add -mX to various FLAGS variables.
4818 4818
4819 4819
4820 4820
4821 4821
4822 4822
4823 4823
4824 4824 #
4825 4825 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4826 4826 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4827 4827 #
4828 4828 # This code is free software; you can redistribute it and/or modify it
4829 4829 # under the terms of the GNU General Public License version 2 only, as
4830 4830 # published by the Free Software Foundation. Oracle designates this
4831 4831 # particular file as subject to the "Classpath" exception as provided
4832 4832 # by Oracle in the LICENSE file that accompanied this code.
4833 4833 #
4834 4834 # This code is distributed in the hope that it will be useful, but WITHOUT
4835 4835 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4836 4836 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4837 4837 # version 2 for more details (a copy is included in the LICENSE file that
4838 4838 # accompanied this code).
4839 4839 #
4840 4840 # You should have received a copy of the GNU General Public License version
4841 4841 # 2 along with this work; if not, write to the Free Software Foundation,
4842 4842 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4843 4843 #
4844 4844 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4845 4845 # or visit www.oracle.com if you need additional information or have any
4846 4846 # questions.
4847 4847 #
4848 4848
4849 4849
4850 4850
4851 4851
4852 4852
4853 4853
4854 4854
4855 4855 ################################################################################
4856 4856 # Define a mechanism for importing extra prebuilt modules
4857 4857 #
4858 4858
4859 4859
4860 4860
4861 4861 #
4862 4862 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4863 4863 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4864 4864 #
4865 4865 # This code is free software; you can redistribute it and/or modify it
4866 4866 # under the terms of the GNU General Public License version 2 only, as
4867 4867 # published by the Free Software Foundation. Oracle designates this
4868 4868 # particular file as subject to the "Classpath" exception as provided
4869 4869 # by Oracle in the LICENSE file that accompanied this code.
4870 4870 #
4871 4871 # This code is distributed in the hope that it will be useful, but WITHOUT
4872 4872 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4873 4873 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4874 4874 # version 2 for more details (a copy is included in the LICENSE file that
4875 4875 # accompanied this code).
4876 4876 #
4877 4877 # You should have received a copy of the GNU General Public License version
4878 4878 # 2 along with this work; if not, write to the Free Software Foundation,
4879 4879 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4880 4880 #
4881 4881 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4882 4882 # or visit www.oracle.com if you need additional information or have any
4883 4883 # questions.
4884 4884 #
4885 4885
4886 4886 ########################################################################
4887 4887 # This file is responsible for detecting, verifying and setting up the
4888 4888 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4889 4889 # proper paths to the binaries, but it will not setup any flags.
4890 4890 #
4891 4891 # The binaries used is determined by the toolchain type, which is the family of
4892 4892 # compilers and related tools that are used.
4893 4893 ########################################################################
4894 4894
4895 4895
4896 4896 # All valid toolchains, regardless of platform (used by help.m4)
4897 4897 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4898 4898
4899 4899 # These toolchains are valid on different platforms
4900 4900 VALID_TOOLCHAINS_linux="gcc clang"
4901 4901 VALID_TOOLCHAINS_solaris="solstudio"
4902 4902 VALID_TOOLCHAINS_macosx="gcc clang"
4903 4903 VALID_TOOLCHAINS_aix="xlc"
4904 4904 VALID_TOOLCHAINS_windows="microsoft"
4905 4905
4906 4906 # Toolchain descriptions
4907 4907 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4908 4908 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4909 4909 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4910 4910 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4911 4911 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4912 4912
4913 4913 # Minimum supported versions, empty means unspecified
4914 4914 TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
4915 4915 TOOLCHAIN_MINIMUM_VERSION_gcc="4.3"
4916 4916 TOOLCHAIN_MINIMUM_VERSION_microsoft=""
4917 4917 TOOLCHAIN_MINIMUM_VERSION_solstudio="5.13"
4918 4918 TOOLCHAIN_MINIMUM_VERSION_xlc=""
4919 4919
4920 4920 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4921 4921 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4922 4922 # $1 - optional variable prefix for compiler and version variables (BUILD_)
4923 4923 # $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
4924 4924
4925 4925
4926 4926 # Check if the configured compiler (C and C++) is of a specific version or
4927 4927 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4928 4928 #
4929 4929 # Arguments:
4930 4930 # VERSION: The version string to check against the found version
4931 4931 # IF_AT_LEAST: block to run if the compiler is at least this version (>=)
4932 4932 # IF_OLDER_THAN: block to run if the compiler is older than this version (<)
4933 4933 # PREFIX: Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
4934 4934
4935 4935
4936 4936
4937 4937
4938 4938 # Setup a number of variables describing how native output files are
4939 4939 # named on this platform/toolchain.
4940 4940
4941 4941
4942 4942 # Determine which toolchain type to use, and make sure it is valid for this
4943 4943 # platform. Setup various information about the selected toolchain.
4944 4944
4945 4945
4946 4946 # Before we start detecting the toolchain executables, we might need some
4947 4947 # special setup, e.g. additional paths etc.
4948 4948
4949 4949
4950 4950 # Restore path, etc
4951 4951
4952 4952
4953 4953 # Check if a compiler is of the toolchain type we expect, and save the version
4954 4954 # information from it. If the compiler does not match the expected type,
4955 4955 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4956 4956 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4957 4957 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4958 4958 #
4959 4959 # $1 = compiler to test (CC or CXX)
4960 4960 # $2 = human readable name of compiler (C or C++)
4961 4961
4962 4962
4963 4963 # Try to locate the given C or C++ compiler in the path, or otherwise.
4964 4964 #
4965 4965 # $1 = compiler to test (CC or CXX)
4966 4966 # $2 = human readable name of compiler (C or C++)
4967 4967 # $3 = list of compiler names to search for
4968 4968
4969 4969
4970 4970 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4971 4971 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4972 4972 # archiver (AR). Verify that the compilers are correct according to the
4973 4973 # toolchain type.
4974 4974
4975 4975
4976 4976 # Setup additional tools that is considered a part of the toolchain, but not the
4977 4977 # core part. Many of these are highly platform-specific and do not exist,
4978 4978 # and/or are not needed on all platforms.
4979 4979
4980 4980
4981 4981 # Setup the build tools (i.e, the compiler and linker used to build programs
4982 4982 # that should be run on the build platform, not the target platform, as a build
4983 4983 # helper). Since the non-cross-compile case uses the normal, target compilers
4984 4984 # for this, we can only do this after these have been setup.
4985 4985
4986 4986
4987 4987 # Setup legacy variables that are still needed as alternative ways to refer to
4988 4988 # parts of the toolchain.
4989 4989
4990 4990
4991 4991 # Do some additional checks on the detected tools.
4992 4992
4993 4993
4994 4994 # Setup the JTReg Regression Test Harness.
4995 4995
4996 4996
4997 4997 #
4998 4998 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4999 4999 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5000 5000 #
5001 5001 # This code is free software; you can redistribute it and/or modify it
5002 5002 # under the terms of the GNU General Public License version 2 only, as
5003 5003 # published by the Free Software Foundation. Oracle designates this
5004 5004 # particular file as subject to the "Classpath" exception as provided
5005 5005 # by Oracle in the LICENSE file that accompanied this code.
5006 5006 #
5007 5007 # This code is distributed in the hope that it will be useful, but WITHOUT
5008 5008 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5009 5009 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
5010 5010 # version 2 for more details (a copy is included in the LICENSE file that
5011 5011 # accompanied this code).
5012 5012 #
5013 5013 # You should have received a copy of the GNU General Public License version
5014 5014 # 2 along with this work; if not, write to the Free Software Foundation,
5015 5015 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
5016 5016 #
5017 5017 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
5018 5018 # or visit www.oracle.com if you need additional information or have any
5019 5019 # questions.
5020 5020 #
5021 5021
5022 5022 ################################################################################
5023 5023 # The order of these defines the priority by which we try to find them.
5024 5024 VALID_VS_VERSIONS="2013 2012 2010"
5025 5025
5026 5026 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
5027 5027 VS_VERSION_INTERNAL_2010=100
5028 5028 VS_MSVCR_2010=msvcr100.dll
5029 5029 # We don't use msvcp on Visual Studio 2010
5030 5030 #VS_MSVCP_2010=msvcp100.dll
5031 5031 VS_ENVVAR_2010="VS100COMNTOOLS"
5032 5032 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
5033 5033 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
5034 5034 VS_VS_PLATFORM_NAME_2010="v100"
5035 5035 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
5036 5036
5037 5037 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
5038 5038 VS_VERSION_INTERNAL_2012=110
5039 5039 VS_MSVCR_2012=msvcr110.dll
5040 5040 VS_MSVCP_2012=msvcp110.dll
5041 5041 VS_ENVVAR_2012="VS110COMNTOOLS"
5042 5042 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
5043 5043 VS_SDK_INSTALLDIR_2012=
5044 5044 VS_VS_PLATFORM_NAME_2012="v110"
5045 5045 VS_SDK_PLATFORM_NAME_2012=
5046 5046
5047 5047 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
5048 5048 VS_VERSION_INTERNAL_2013=120
5049 5049 VS_MSVCR_2013=msvcr120.dll
5050 5050 VS_MSVCP_2013=msvcp120.dll
5051 5051 VS_ENVVAR_2013="VS120COMNTOOLS"
5052 5052 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
5053 5053 VS_SDK_INSTALLDIR_2013=
5054 5054 VS_VS_PLATFORM_NAME_2013="v120"
5055 5055 VS_SDK_PLATFORM_NAME_2013=
5056 5056
5057 5057 ################################################################################
5058 5058
5059 5059
5060 5060
5061 5061 ################################################################################
5062 5062
5063 5063
5064 5064
5065 5065 ################################################################################
5066 5066 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
5067 5067 # build environment and assigns it to VS_ENV_CMD
5068 5068
5069 5069
5070 5070 ################################################################################
5071 5071
5072 5072
5073 5073
5074 5074 ################################################################################
5075 5075 # Check if the VS env variables were setup prior to running configure.
5076 5076 # If not, then find vcvarsall.bat and run it automatically, and integrate
5077 5077 # the set env variables into the spec file.
5078 5078
5079 5079
5080 5080
5081 5081
5082 5082
5083 5083
5084 5084
5085 5085
5086 5086
5087 5087
|
↓ open down ↓ |
5087 lines elided |
↑ open up ↑ |
5088 5088
5089 5089
5090 5090
5091 5091
5092 5092 # This line needs to be here, verbatim, after all includes and the dummy hook
5093 5093 # definitions. It is replaced with custom functionality when building
5094 5094 # custom sources.
5095 5095 #CUSTOM_AUTOCONF_INCLUDE
5096 5096
5097 5097 # Do not change or remove the following line, it is needed for consistency checks:
5098 -DATE_WHEN_GENERATED=1470863189
5098 +DATE_WHEN_GENERATED=1472736962
5099 5099
5100 5100 ###############################################################################
5101 5101 #
5102 5102 # Initialization / Boot-strapping
5103 5103 #
5104 5104 # The bootstrapping process needs to solve the "chicken or the egg" problem,
5105 5105 # thus it jumps back and forth, each time gaining something needed later on.
5106 5106 #
5107 5107 ###############################################################################
5108 5108
5109 5109 # If we are requested to print additional help, do that and then exit.
5110 5110 # This must be the very first call.
5111 5111
5112 5112 if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
5113 5113
5114 5114 # Print available toolchains
5115 5115 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
5116 5116 $PRINTF "Which are valid to use depends on the build platform.\n"
5117 5117 for toolchain in $VALID_TOOLCHAINS_all; do
5118 5118 # Use indirect variable referencing
5119 5119 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
5120 5120 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5121 5121 $PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
5122 5122 done
5123 5123 $PRINTF "\n"
5124 5124
5125 5125 # Print available jvm features
5126 5126 $PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
5127 5127 $PRINTF "Which are valid to use depends on the target platform.\n "
5128 5128 $PRINTF "%s " $VALID_JVM_FEATURES
5129 5129 $PRINTF "\n"
5130 5130
5131 5131 # And now exit directly
5132 5132 exit 0
5133 5133 fi
5134 5134
5135 5135
5136 5136 # Basic initialization that must happen first of all in the normal process.
5137 5137
5138 5138 # Save the original command line. This is passed to us by the wrapper configure script.
5139 5139
5140 5140 # Save the path variable before it gets changed
5141 5141 ORIGINAL_PATH="$PATH"
5142 5142
5143 5143 DATE_WHEN_CONFIGURED=`LANG=C date`
5144 5144
5145 5145 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
5146 5146 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
5147 5147 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
5148 5148 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
5149 5149
5150 5150
5151 5151 # Start with tools that do not need have cross compilation support
5152 5152 # and can be expected to be found in the default PATH. These tools are
5153 5153 # used by configure.
5154 5154
5155 5155 # First are all the simple required tools.
5156 5156
5157 5157
5158 5158
5159 5159 # Publish this variable in the help.
5160 5160
5161 5161
5162 5162 if [ -z "${BASENAME+x}" ]; then
5163 5163 # The variable is not set by user, try to locate tool using the code snippet
5164 5164 for ac_prog in basename
5165 5165 do
5166 5166 # Extract the first word of "$ac_prog", so it can be a program name with args.
5167 5167 set dummy $ac_prog; ac_word=$2
5168 5168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5169 5169 $as_echo_n "checking for $ac_word... " >&6; }
5170 5170 if ${ac_cv_path_BASENAME+:} false; then :
5171 5171 $as_echo_n "(cached) " >&6
5172 5172 else
5173 5173 case $BASENAME in
5174 5174 [\\/]* | ?:[\\/]*)
5175 5175 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5176 5176 ;;
5177 5177 *)
5178 5178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5179 5179 for as_dir in $PATH
5180 5180 do
5181 5181 IFS=$as_save_IFS
5182 5182 test -z "$as_dir" && as_dir=.
5183 5183 for ac_exec_ext in '' $ac_executable_extensions; do
5184 5184 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5185 5185 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5186 5186 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5187 5187 break 2
5188 5188 fi
5189 5189 done
5190 5190 done
5191 5191 IFS=$as_save_IFS
5192 5192
5193 5193 ;;
5194 5194 esac
5195 5195 fi
5196 5196 BASENAME=$ac_cv_path_BASENAME
5197 5197 if test -n "$BASENAME"; then
5198 5198 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5199 5199 $as_echo "$BASENAME" >&6; }
5200 5200 else
5201 5201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5202 5202 $as_echo "no" >&6; }
5203 5203 fi
5204 5204
5205 5205
5206 5206 test -n "$BASENAME" && break
5207 5207 done
5208 5208
5209 5209 else
5210 5210 # The variable is set, but is it from the command line or the environment?
5211 5211
5212 5212 # Try to remove the string !BASENAME! from our list.
5213 5213 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
5214 5214 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5215 5215 # If it failed, the variable was not from the command line. Ignore it,
5216 5216 # but warn the user (except for BASH, which is always set by the calling BASH).
5217 5217 if test "xBASENAME" != xBASH; then
5218 5218 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
5219 5219 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
5220 5220 fi
5221 5221 # Try to locate tool using the code snippet
5222 5222 for ac_prog in basename
5223 5223 do
5224 5224 # Extract the first word of "$ac_prog", so it can be a program name with args.
5225 5225 set dummy $ac_prog; ac_word=$2
5226 5226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5227 5227 $as_echo_n "checking for $ac_word... " >&6; }
5228 5228 if ${ac_cv_path_BASENAME+:} false; then :
5229 5229 $as_echo_n "(cached) " >&6
5230 5230 else
5231 5231 case $BASENAME in
5232 5232 [\\/]* | ?:[\\/]*)
5233 5233 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5234 5234 ;;
5235 5235 *)
5236 5236 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5237 5237 for as_dir in $PATH
5238 5238 do
5239 5239 IFS=$as_save_IFS
5240 5240 test -z "$as_dir" && as_dir=.
5241 5241 for ac_exec_ext in '' $ac_executable_extensions; do
5242 5242 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5243 5243 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5244 5244 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5245 5245 break 2
5246 5246 fi
5247 5247 done
5248 5248 done
5249 5249 IFS=$as_save_IFS
5250 5250
5251 5251 ;;
5252 5252 esac
5253 5253 fi
5254 5254 BASENAME=$ac_cv_path_BASENAME
5255 5255 if test -n "$BASENAME"; then
5256 5256 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5257 5257 $as_echo "$BASENAME" >&6; }
5258 5258 else
5259 5259 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5260 5260 $as_echo "no" >&6; }
5261 5261 fi
5262 5262
5263 5263
5264 5264 test -n "$BASENAME" && break
5265 5265 done
5266 5266
5267 5267 else
5268 5268 # If it succeeded, then it was overridden by the user. We will use it
5269 5269 # for the tool.
5270 5270
5271 5271 # First remove it from the list of overridden variables, so we can test
5272 5272 # for unknown variables in the end.
5273 5273 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5274 5274
5275 5275 # Check if we try to supply an empty value
5276 5276 if test "x$BASENAME" = x; then
5277 5277 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
5278 5278 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
5279 5279 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5280 5280 $as_echo_n "checking for BASENAME... " >&6; }
5281 5281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5282 5282 $as_echo "disabled" >&6; }
5283 5283 else
5284 5284 # Check if the provided tool contains a complete path.
5285 5285 tool_specified="$BASENAME"
5286 5286 tool_basename="${tool_specified##*/}"
5287 5287 if test "x$tool_basename" = "x$tool_specified"; then
5288 5288 # A command without a complete path is provided, search $PATH.
5289 5289 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
5290 5290 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
5291 5291 # Extract the first word of "$tool_basename", so it can be a program name with args.
5292 5292 set dummy $tool_basename; ac_word=$2
5293 5293 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5294 5294 $as_echo_n "checking for $ac_word... " >&6; }
5295 5295 if ${ac_cv_path_BASENAME+:} false; then :
5296 5296 $as_echo_n "(cached) " >&6
5297 5297 else
5298 5298 case $BASENAME in
5299 5299 [\\/]* | ?:[\\/]*)
5300 5300 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5301 5301 ;;
5302 5302 *)
5303 5303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5304 5304 for as_dir in $PATH
5305 5305 do
5306 5306 IFS=$as_save_IFS
5307 5307 test -z "$as_dir" && as_dir=.
5308 5308 for ac_exec_ext in '' $ac_executable_extensions; do
5309 5309 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5310 5310 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5311 5311 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5312 5312 break 2
5313 5313 fi
5314 5314 done
5315 5315 done
5316 5316 IFS=$as_save_IFS
5317 5317
5318 5318 ;;
5319 5319 esac
5320 5320 fi
5321 5321 BASENAME=$ac_cv_path_BASENAME
5322 5322 if test -n "$BASENAME"; then
5323 5323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5324 5324 $as_echo "$BASENAME" >&6; }
5325 5325 else
5326 5326 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5327 5327 $as_echo "no" >&6; }
5328 5328 fi
5329 5329
5330 5330
5331 5331 if test "x$BASENAME" = x; then
5332 5332 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5333 5333 fi
5334 5334 else
5335 5335 # Otherwise we believe it is a complete path. Use it as it is.
5336 5336 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
5337 5337 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
5338 5338 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5339 5339 $as_echo_n "checking for BASENAME... " >&6; }
5340 5340 if test ! -x "$tool_specified"; then
5341 5341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5342 5342 $as_echo "not found" >&6; }
5343 5343 as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
5344 5344 fi
5345 5345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5346 5346 $as_echo "$tool_specified" >&6; }
5347 5347 fi
5348 5348 fi
5349 5349 fi
5350 5350
5351 5351 fi
5352 5352
5353 5353
5354 5354
5355 5355 if test "x$BASENAME" = x; then
5356 5356 as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
5357 5357 fi
5358 5358
5359 5359
5360 5360
5361 5361
5362 5362
5363 5363 # Publish this variable in the help.
5364 5364
5365 5365
5366 5366 if [ -z "${BASH+x}" ]; then
5367 5367 # The variable is not set by user, try to locate tool using the code snippet
5368 5368 for ac_prog in bash
5369 5369 do
5370 5370 # Extract the first word of "$ac_prog", so it can be a program name with args.
5371 5371 set dummy $ac_prog; ac_word=$2
5372 5372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5373 5373 $as_echo_n "checking for $ac_word... " >&6; }
5374 5374 if ${ac_cv_path_BASH+:} false; then :
5375 5375 $as_echo_n "(cached) " >&6
5376 5376 else
5377 5377 case $BASH in
5378 5378 [\\/]* | ?:[\\/]*)
5379 5379 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5380 5380 ;;
5381 5381 *)
5382 5382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5383 5383 for as_dir in $PATH
5384 5384 do
5385 5385 IFS=$as_save_IFS
5386 5386 test -z "$as_dir" && as_dir=.
5387 5387 for ac_exec_ext in '' $ac_executable_extensions; do
5388 5388 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5389 5389 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5390 5390 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5391 5391 break 2
5392 5392 fi
5393 5393 done
5394 5394 done
5395 5395 IFS=$as_save_IFS
5396 5396
5397 5397 ;;
5398 5398 esac
5399 5399 fi
5400 5400 BASH=$ac_cv_path_BASH
5401 5401 if test -n "$BASH"; then
5402 5402 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5403 5403 $as_echo "$BASH" >&6; }
5404 5404 else
5405 5405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5406 5406 $as_echo "no" >&6; }
5407 5407 fi
5408 5408
5409 5409
5410 5410 test -n "$BASH" && break
5411 5411 done
5412 5412
5413 5413 else
5414 5414 # The variable is set, but is it from the command line or the environment?
5415 5415
5416 5416 # Try to remove the string !BASH! from our list.
5417 5417 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5418 5418 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5419 5419 # If it failed, the variable was not from the command line. Ignore it,
5420 5420 # but warn the user (except for BASH, which is always set by the calling BASH).
5421 5421 if test "xBASH" != xBASH; then
5422 5422 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5423 5423 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5424 5424 fi
5425 5425 # Try to locate tool using the code snippet
5426 5426 for ac_prog in bash
5427 5427 do
5428 5428 # Extract the first word of "$ac_prog", so it can be a program name with args.
5429 5429 set dummy $ac_prog; ac_word=$2
5430 5430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5431 5431 $as_echo_n "checking for $ac_word... " >&6; }
5432 5432 if ${ac_cv_path_BASH+:} false; then :
5433 5433 $as_echo_n "(cached) " >&6
5434 5434 else
5435 5435 case $BASH in
5436 5436 [\\/]* | ?:[\\/]*)
5437 5437 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5438 5438 ;;
5439 5439 *)
5440 5440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5441 5441 for as_dir in $PATH
5442 5442 do
5443 5443 IFS=$as_save_IFS
5444 5444 test -z "$as_dir" && as_dir=.
5445 5445 for ac_exec_ext in '' $ac_executable_extensions; do
5446 5446 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5447 5447 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5448 5448 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5449 5449 break 2
5450 5450 fi
5451 5451 done
5452 5452 done
5453 5453 IFS=$as_save_IFS
5454 5454
5455 5455 ;;
5456 5456 esac
5457 5457 fi
5458 5458 BASH=$ac_cv_path_BASH
5459 5459 if test -n "$BASH"; then
5460 5460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5461 5461 $as_echo "$BASH" >&6; }
5462 5462 else
5463 5463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5464 5464 $as_echo "no" >&6; }
5465 5465 fi
5466 5466
5467 5467
5468 5468 test -n "$BASH" && break
5469 5469 done
5470 5470
5471 5471 else
5472 5472 # If it succeeded, then it was overridden by the user. We will use it
5473 5473 # for the tool.
5474 5474
5475 5475 # First remove it from the list of overridden variables, so we can test
5476 5476 # for unknown variables in the end.
5477 5477 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5478 5478
5479 5479 # Check if we try to supply an empty value
5480 5480 if test "x$BASH" = x; then
5481 5481 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5482 5482 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5483 5483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5484 5484 $as_echo_n "checking for BASH... " >&6; }
5485 5485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5486 5486 $as_echo "disabled" >&6; }
5487 5487 else
5488 5488 # Check if the provided tool contains a complete path.
5489 5489 tool_specified="$BASH"
5490 5490 tool_basename="${tool_specified##*/}"
5491 5491 if test "x$tool_basename" = "x$tool_specified"; then
5492 5492 # A command without a complete path is provided, search $PATH.
5493 5493 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5494 5494 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5495 5495 # Extract the first word of "$tool_basename", so it can be a program name with args.
5496 5496 set dummy $tool_basename; ac_word=$2
5497 5497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5498 5498 $as_echo_n "checking for $ac_word... " >&6; }
5499 5499 if ${ac_cv_path_BASH+:} false; then :
5500 5500 $as_echo_n "(cached) " >&6
5501 5501 else
5502 5502 case $BASH in
5503 5503 [\\/]* | ?:[\\/]*)
5504 5504 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5505 5505 ;;
5506 5506 *)
5507 5507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5508 5508 for as_dir in $PATH
5509 5509 do
5510 5510 IFS=$as_save_IFS
5511 5511 test -z "$as_dir" && as_dir=.
5512 5512 for ac_exec_ext in '' $ac_executable_extensions; do
5513 5513 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5514 5514 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5515 5515 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5516 5516 break 2
5517 5517 fi
5518 5518 done
5519 5519 done
5520 5520 IFS=$as_save_IFS
5521 5521
5522 5522 ;;
5523 5523 esac
5524 5524 fi
5525 5525 BASH=$ac_cv_path_BASH
5526 5526 if test -n "$BASH"; then
5527 5527 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5528 5528 $as_echo "$BASH" >&6; }
5529 5529 else
5530 5530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5531 5531 $as_echo "no" >&6; }
5532 5532 fi
5533 5533
5534 5534
5535 5535 if test "x$BASH" = x; then
5536 5536 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5537 5537 fi
5538 5538 else
5539 5539 # Otherwise we believe it is a complete path. Use it as it is.
5540 5540 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5541 5541 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5542 5542 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5543 5543 $as_echo_n "checking for BASH... " >&6; }
5544 5544 if test ! -x "$tool_specified"; then
5545 5545 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5546 5546 $as_echo "not found" >&6; }
5547 5547 as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5548 5548 fi
5549 5549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5550 5550 $as_echo "$tool_specified" >&6; }
5551 5551 fi
5552 5552 fi
5553 5553 fi
5554 5554
5555 5555 fi
5556 5556
5557 5557
5558 5558
5559 5559 if test "x$BASH" = x; then
5560 5560 as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5561 5561 fi
5562 5562
5563 5563
5564 5564
5565 5565
5566 5566
5567 5567 # Publish this variable in the help.
5568 5568
5569 5569
5570 5570 if [ -z "${CAT+x}" ]; then
5571 5571 # The variable is not set by user, try to locate tool using the code snippet
5572 5572 for ac_prog in cat
5573 5573 do
5574 5574 # Extract the first word of "$ac_prog", so it can be a program name with args.
5575 5575 set dummy $ac_prog; ac_word=$2
5576 5576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5577 5577 $as_echo_n "checking for $ac_word... " >&6; }
5578 5578 if ${ac_cv_path_CAT+:} false; then :
5579 5579 $as_echo_n "(cached) " >&6
5580 5580 else
5581 5581 case $CAT in
5582 5582 [\\/]* | ?:[\\/]*)
5583 5583 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5584 5584 ;;
5585 5585 *)
5586 5586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5587 5587 for as_dir in $PATH
5588 5588 do
5589 5589 IFS=$as_save_IFS
5590 5590 test -z "$as_dir" && as_dir=.
5591 5591 for ac_exec_ext in '' $ac_executable_extensions; do
5592 5592 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5593 5593 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5594 5594 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5595 5595 break 2
5596 5596 fi
5597 5597 done
5598 5598 done
5599 5599 IFS=$as_save_IFS
5600 5600
5601 5601 ;;
5602 5602 esac
5603 5603 fi
5604 5604 CAT=$ac_cv_path_CAT
5605 5605 if test -n "$CAT"; then
5606 5606 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5607 5607 $as_echo "$CAT" >&6; }
5608 5608 else
5609 5609 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5610 5610 $as_echo "no" >&6; }
5611 5611 fi
5612 5612
5613 5613
5614 5614 test -n "$CAT" && break
5615 5615 done
5616 5616
5617 5617 else
5618 5618 # The variable is set, but is it from the command line or the environment?
5619 5619
5620 5620 # Try to remove the string !CAT! from our list.
5621 5621 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5622 5622 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5623 5623 # If it failed, the variable was not from the command line. Ignore it,
5624 5624 # but warn the user (except for BASH, which is always set by the calling BASH).
5625 5625 if test "xCAT" != xBASH; then
5626 5626 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5627 5627 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5628 5628 fi
5629 5629 # Try to locate tool using the code snippet
5630 5630 for ac_prog in cat
5631 5631 do
5632 5632 # Extract the first word of "$ac_prog", so it can be a program name with args.
5633 5633 set dummy $ac_prog; ac_word=$2
5634 5634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5635 5635 $as_echo_n "checking for $ac_word... " >&6; }
5636 5636 if ${ac_cv_path_CAT+:} false; then :
5637 5637 $as_echo_n "(cached) " >&6
5638 5638 else
5639 5639 case $CAT in
5640 5640 [\\/]* | ?:[\\/]*)
5641 5641 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5642 5642 ;;
5643 5643 *)
5644 5644 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5645 5645 for as_dir in $PATH
5646 5646 do
5647 5647 IFS=$as_save_IFS
5648 5648 test -z "$as_dir" && as_dir=.
5649 5649 for ac_exec_ext in '' $ac_executable_extensions; do
5650 5650 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5651 5651 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5652 5652 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5653 5653 break 2
5654 5654 fi
5655 5655 done
5656 5656 done
5657 5657 IFS=$as_save_IFS
5658 5658
5659 5659 ;;
5660 5660 esac
5661 5661 fi
5662 5662 CAT=$ac_cv_path_CAT
5663 5663 if test -n "$CAT"; then
5664 5664 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5665 5665 $as_echo "$CAT" >&6; }
5666 5666 else
5667 5667 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5668 5668 $as_echo "no" >&6; }
5669 5669 fi
5670 5670
5671 5671
5672 5672 test -n "$CAT" && break
5673 5673 done
5674 5674
5675 5675 else
5676 5676 # If it succeeded, then it was overridden by the user. We will use it
5677 5677 # for the tool.
5678 5678
5679 5679 # First remove it from the list of overridden variables, so we can test
5680 5680 # for unknown variables in the end.
5681 5681 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5682 5682
5683 5683 # Check if we try to supply an empty value
5684 5684 if test "x$CAT" = x; then
5685 5685 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5686 5686 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5687 5687 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5688 5688 $as_echo_n "checking for CAT... " >&6; }
5689 5689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5690 5690 $as_echo "disabled" >&6; }
5691 5691 else
5692 5692 # Check if the provided tool contains a complete path.
5693 5693 tool_specified="$CAT"
5694 5694 tool_basename="${tool_specified##*/}"
5695 5695 if test "x$tool_basename" = "x$tool_specified"; then
5696 5696 # A command without a complete path is provided, search $PATH.
5697 5697 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5698 5698 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5699 5699 # Extract the first word of "$tool_basename", so it can be a program name with args.
5700 5700 set dummy $tool_basename; ac_word=$2
5701 5701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5702 5702 $as_echo_n "checking for $ac_word... " >&6; }
5703 5703 if ${ac_cv_path_CAT+:} false; then :
5704 5704 $as_echo_n "(cached) " >&6
5705 5705 else
5706 5706 case $CAT in
5707 5707 [\\/]* | ?:[\\/]*)
5708 5708 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5709 5709 ;;
5710 5710 *)
5711 5711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5712 5712 for as_dir in $PATH
5713 5713 do
5714 5714 IFS=$as_save_IFS
5715 5715 test -z "$as_dir" && as_dir=.
5716 5716 for ac_exec_ext in '' $ac_executable_extensions; do
5717 5717 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5718 5718 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5719 5719 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5720 5720 break 2
5721 5721 fi
5722 5722 done
5723 5723 done
5724 5724 IFS=$as_save_IFS
5725 5725
5726 5726 ;;
5727 5727 esac
5728 5728 fi
5729 5729 CAT=$ac_cv_path_CAT
5730 5730 if test -n "$CAT"; then
5731 5731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5732 5732 $as_echo "$CAT" >&6; }
5733 5733 else
5734 5734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5735 5735 $as_echo "no" >&6; }
5736 5736 fi
5737 5737
5738 5738
5739 5739 if test "x$CAT" = x; then
5740 5740 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5741 5741 fi
5742 5742 else
5743 5743 # Otherwise we believe it is a complete path. Use it as it is.
5744 5744 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5745 5745 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5746 5746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5747 5747 $as_echo_n "checking for CAT... " >&6; }
5748 5748 if test ! -x "$tool_specified"; then
5749 5749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5750 5750 $as_echo "not found" >&6; }
5751 5751 as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5752 5752 fi
5753 5753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5754 5754 $as_echo "$tool_specified" >&6; }
5755 5755 fi
5756 5756 fi
5757 5757 fi
5758 5758
5759 5759 fi
5760 5760
5761 5761
5762 5762
5763 5763 if test "x$CAT" = x; then
5764 5764 as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5765 5765 fi
5766 5766
5767 5767
5768 5768
5769 5769
5770 5770
5771 5771 # Publish this variable in the help.
5772 5772
5773 5773
5774 5774 if [ -z "${CHMOD+x}" ]; then
5775 5775 # The variable is not set by user, try to locate tool using the code snippet
5776 5776 for ac_prog in chmod
5777 5777 do
5778 5778 # Extract the first word of "$ac_prog", so it can be a program name with args.
5779 5779 set dummy $ac_prog; ac_word=$2
5780 5780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5781 5781 $as_echo_n "checking for $ac_word... " >&6; }
5782 5782 if ${ac_cv_path_CHMOD+:} false; then :
5783 5783 $as_echo_n "(cached) " >&6
5784 5784 else
5785 5785 case $CHMOD in
5786 5786 [\\/]* | ?:[\\/]*)
5787 5787 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5788 5788 ;;
5789 5789 *)
5790 5790 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5791 5791 for as_dir in $PATH
5792 5792 do
5793 5793 IFS=$as_save_IFS
5794 5794 test -z "$as_dir" && as_dir=.
5795 5795 for ac_exec_ext in '' $ac_executable_extensions; do
5796 5796 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5797 5797 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5798 5798 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5799 5799 break 2
5800 5800 fi
5801 5801 done
5802 5802 done
5803 5803 IFS=$as_save_IFS
5804 5804
5805 5805 ;;
5806 5806 esac
5807 5807 fi
5808 5808 CHMOD=$ac_cv_path_CHMOD
5809 5809 if test -n "$CHMOD"; then
5810 5810 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5811 5811 $as_echo "$CHMOD" >&6; }
5812 5812 else
5813 5813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5814 5814 $as_echo "no" >&6; }
5815 5815 fi
5816 5816
5817 5817
5818 5818 test -n "$CHMOD" && break
5819 5819 done
5820 5820
5821 5821 else
5822 5822 # The variable is set, but is it from the command line or the environment?
5823 5823
5824 5824 # Try to remove the string !CHMOD! from our list.
5825 5825 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5826 5826 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5827 5827 # If it failed, the variable was not from the command line. Ignore it,
5828 5828 # but warn the user (except for BASH, which is always set by the calling BASH).
5829 5829 if test "xCHMOD" != xBASH; then
5830 5830 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5831 5831 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5832 5832 fi
5833 5833 # Try to locate tool using the code snippet
5834 5834 for ac_prog in chmod
5835 5835 do
5836 5836 # Extract the first word of "$ac_prog", so it can be a program name with args.
5837 5837 set dummy $ac_prog; ac_word=$2
5838 5838 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5839 5839 $as_echo_n "checking for $ac_word... " >&6; }
5840 5840 if ${ac_cv_path_CHMOD+:} false; then :
5841 5841 $as_echo_n "(cached) " >&6
5842 5842 else
5843 5843 case $CHMOD in
5844 5844 [\\/]* | ?:[\\/]*)
5845 5845 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5846 5846 ;;
5847 5847 *)
5848 5848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5849 5849 for as_dir in $PATH
5850 5850 do
5851 5851 IFS=$as_save_IFS
5852 5852 test -z "$as_dir" && as_dir=.
5853 5853 for ac_exec_ext in '' $ac_executable_extensions; do
5854 5854 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5855 5855 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5856 5856 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5857 5857 break 2
5858 5858 fi
5859 5859 done
5860 5860 done
5861 5861 IFS=$as_save_IFS
5862 5862
5863 5863 ;;
5864 5864 esac
5865 5865 fi
5866 5866 CHMOD=$ac_cv_path_CHMOD
5867 5867 if test -n "$CHMOD"; then
5868 5868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5869 5869 $as_echo "$CHMOD" >&6; }
5870 5870 else
5871 5871 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5872 5872 $as_echo "no" >&6; }
5873 5873 fi
5874 5874
5875 5875
5876 5876 test -n "$CHMOD" && break
5877 5877 done
5878 5878
5879 5879 else
5880 5880 # If it succeeded, then it was overridden by the user. We will use it
5881 5881 # for the tool.
5882 5882
5883 5883 # First remove it from the list of overridden variables, so we can test
5884 5884 # for unknown variables in the end.
5885 5885 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5886 5886
5887 5887 # Check if we try to supply an empty value
5888 5888 if test "x$CHMOD" = x; then
5889 5889 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5890 5890 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5891 5891 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5892 5892 $as_echo_n "checking for CHMOD... " >&6; }
5893 5893 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5894 5894 $as_echo "disabled" >&6; }
5895 5895 else
5896 5896 # Check if the provided tool contains a complete path.
5897 5897 tool_specified="$CHMOD"
5898 5898 tool_basename="${tool_specified##*/}"
5899 5899 if test "x$tool_basename" = "x$tool_specified"; then
5900 5900 # A command without a complete path is provided, search $PATH.
5901 5901 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5902 5902 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5903 5903 # Extract the first word of "$tool_basename", so it can be a program name with args.
5904 5904 set dummy $tool_basename; ac_word=$2
5905 5905 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5906 5906 $as_echo_n "checking for $ac_word... " >&6; }
5907 5907 if ${ac_cv_path_CHMOD+:} false; then :
5908 5908 $as_echo_n "(cached) " >&6
5909 5909 else
5910 5910 case $CHMOD in
5911 5911 [\\/]* | ?:[\\/]*)
5912 5912 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5913 5913 ;;
5914 5914 *)
5915 5915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5916 5916 for as_dir in $PATH
5917 5917 do
5918 5918 IFS=$as_save_IFS
5919 5919 test -z "$as_dir" && as_dir=.
5920 5920 for ac_exec_ext in '' $ac_executable_extensions; do
5921 5921 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5922 5922 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5923 5923 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5924 5924 break 2
5925 5925 fi
5926 5926 done
5927 5927 done
5928 5928 IFS=$as_save_IFS
5929 5929
5930 5930 ;;
5931 5931 esac
5932 5932 fi
5933 5933 CHMOD=$ac_cv_path_CHMOD
5934 5934 if test -n "$CHMOD"; then
5935 5935 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5936 5936 $as_echo "$CHMOD" >&6; }
5937 5937 else
5938 5938 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5939 5939 $as_echo "no" >&6; }
5940 5940 fi
5941 5941
5942 5942
5943 5943 if test "x$CHMOD" = x; then
5944 5944 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5945 5945 fi
5946 5946 else
5947 5947 # Otherwise we believe it is a complete path. Use it as it is.
5948 5948 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5949 5949 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5950 5950 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5951 5951 $as_echo_n "checking for CHMOD... " >&6; }
5952 5952 if test ! -x "$tool_specified"; then
5953 5953 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5954 5954 $as_echo "not found" >&6; }
5955 5955 as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5956 5956 fi
5957 5957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5958 5958 $as_echo "$tool_specified" >&6; }
5959 5959 fi
5960 5960 fi
5961 5961 fi
5962 5962
5963 5963 fi
5964 5964
5965 5965
5966 5966
5967 5967 if test "x$CHMOD" = x; then
5968 5968 as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5969 5969 fi
5970 5970
5971 5971
5972 5972
5973 5973
5974 5974
5975 5975 # Publish this variable in the help.
5976 5976
5977 5977
5978 5978 if [ -z "${CMP+x}" ]; then
5979 5979 # The variable is not set by user, try to locate tool using the code snippet
5980 5980 for ac_prog in cmp
5981 5981 do
5982 5982 # Extract the first word of "$ac_prog", so it can be a program name with args.
5983 5983 set dummy $ac_prog; ac_word=$2
5984 5984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5985 5985 $as_echo_n "checking for $ac_word... " >&6; }
5986 5986 if ${ac_cv_path_CMP+:} false; then :
5987 5987 $as_echo_n "(cached) " >&6
5988 5988 else
5989 5989 case $CMP in
5990 5990 [\\/]* | ?:[\\/]*)
5991 5991 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5992 5992 ;;
5993 5993 *)
5994 5994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5995 5995 for as_dir in $PATH
5996 5996 do
5997 5997 IFS=$as_save_IFS
5998 5998 test -z "$as_dir" && as_dir=.
5999 5999 for ac_exec_ext in '' $ac_executable_extensions; do
6000 6000 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6001 6001 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6002 6002 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6003 6003 break 2
6004 6004 fi
6005 6005 done
6006 6006 done
6007 6007 IFS=$as_save_IFS
6008 6008
6009 6009 ;;
6010 6010 esac
6011 6011 fi
6012 6012 CMP=$ac_cv_path_CMP
6013 6013 if test -n "$CMP"; then
6014 6014 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6015 6015 $as_echo "$CMP" >&6; }
6016 6016 else
6017 6017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6018 6018 $as_echo "no" >&6; }
6019 6019 fi
6020 6020
6021 6021
6022 6022 test -n "$CMP" && break
6023 6023 done
6024 6024
6025 6025 else
6026 6026 # The variable is set, but is it from the command line or the environment?
6027 6027
6028 6028 # Try to remove the string !CMP! from our list.
6029 6029 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
6030 6030 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6031 6031 # If it failed, the variable was not from the command line. Ignore it,
6032 6032 # but warn the user (except for BASH, which is always set by the calling BASH).
6033 6033 if test "xCMP" != xBASH; then
6034 6034 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
6035 6035 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
6036 6036 fi
6037 6037 # Try to locate tool using the code snippet
6038 6038 for ac_prog in cmp
6039 6039 do
6040 6040 # Extract the first word of "$ac_prog", so it can be a program name with args.
6041 6041 set dummy $ac_prog; ac_word=$2
6042 6042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6043 6043 $as_echo_n "checking for $ac_word... " >&6; }
6044 6044 if ${ac_cv_path_CMP+:} false; then :
6045 6045 $as_echo_n "(cached) " >&6
6046 6046 else
6047 6047 case $CMP in
6048 6048 [\\/]* | ?:[\\/]*)
6049 6049 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6050 6050 ;;
6051 6051 *)
6052 6052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6053 6053 for as_dir in $PATH
6054 6054 do
6055 6055 IFS=$as_save_IFS
6056 6056 test -z "$as_dir" && as_dir=.
6057 6057 for ac_exec_ext in '' $ac_executable_extensions; do
6058 6058 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6059 6059 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6060 6060 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6061 6061 break 2
6062 6062 fi
6063 6063 done
6064 6064 done
6065 6065 IFS=$as_save_IFS
6066 6066
6067 6067 ;;
6068 6068 esac
6069 6069 fi
6070 6070 CMP=$ac_cv_path_CMP
6071 6071 if test -n "$CMP"; then
6072 6072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6073 6073 $as_echo "$CMP" >&6; }
6074 6074 else
6075 6075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6076 6076 $as_echo "no" >&6; }
6077 6077 fi
6078 6078
6079 6079
6080 6080 test -n "$CMP" && break
6081 6081 done
6082 6082
6083 6083 else
6084 6084 # If it succeeded, then it was overridden by the user. We will use it
6085 6085 # for the tool.
6086 6086
6087 6087 # First remove it from the list of overridden variables, so we can test
6088 6088 # for unknown variables in the end.
6089 6089 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6090 6090
6091 6091 # Check if we try to supply an empty value
6092 6092 if test "x$CMP" = x; then
6093 6093 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
6094 6094 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
6095 6095 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6096 6096 $as_echo_n "checking for CMP... " >&6; }
6097 6097 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6098 6098 $as_echo "disabled" >&6; }
6099 6099 else
6100 6100 # Check if the provided tool contains a complete path.
6101 6101 tool_specified="$CMP"
6102 6102 tool_basename="${tool_specified##*/}"
6103 6103 if test "x$tool_basename" = "x$tool_specified"; then
6104 6104 # A command without a complete path is provided, search $PATH.
6105 6105 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
6106 6106 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
6107 6107 # Extract the first word of "$tool_basename", so it can be a program name with args.
6108 6108 set dummy $tool_basename; ac_word=$2
6109 6109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6110 6110 $as_echo_n "checking for $ac_word... " >&6; }
6111 6111 if ${ac_cv_path_CMP+:} false; then :
6112 6112 $as_echo_n "(cached) " >&6
6113 6113 else
6114 6114 case $CMP in
6115 6115 [\\/]* | ?:[\\/]*)
6116 6116 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6117 6117 ;;
6118 6118 *)
6119 6119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6120 6120 for as_dir in $PATH
6121 6121 do
6122 6122 IFS=$as_save_IFS
6123 6123 test -z "$as_dir" && as_dir=.
6124 6124 for ac_exec_ext in '' $ac_executable_extensions; do
6125 6125 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6126 6126 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6127 6127 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6128 6128 break 2
6129 6129 fi
6130 6130 done
6131 6131 done
6132 6132 IFS=$as_save_IFS
6133 6133
6134 6134 ;;
6135 6135 esac
6136 6136 fi
6137 6137 CMP=$ac_cv_path_CMP
6138 6138 if test -n "$CMP"; then
6139 6139 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6140 6140 $as_echo "$CMP" >&6; }
6141 6141 else
6142 6142 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6143 6143 $as_echo "no" >&6; }
6144 6144 fi
6145 6145
6146 6146
6147 6147 if test "x$CMP" = x; then
6148 6148 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6149 6149 fi
6150 6150 else
6151 6151 # Otherwise we believe it is a complete path. Use it as it is.
6152 6152 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
6153 6153 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
6154 6154 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6155 6155 $as_echo_n "checking for CMP... " >&6; }
6156 6156 if test ! -x "$tool_specified"; then
6157 6157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6158 6158 $as_echo "not found" >&6; }
6159 6159 as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
6160 6160 fi
6161 6161 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6162 6162 $as_echo "$tool_specified" >&6; }
6163 6163 fi
6164 6164 fi
6165 6165 fi
6166 6166
6167 6167 fi
6168 6168
6169 6169
6170 6170
6171 6171 if test "x$CMP" = x; then
6172 6172 as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
6173 6173 fi
6174 6174
6175 6175
6176 6176
6177 6177
6178 6178
6179 6179 # Publish this variable in the help.
6180 6180
6181 6181
6182 6182 if [ -z "${COMM+x}" ]; then
6183 6183 # The variable is not set by user, try to locate tool using the code snippet
6184 6184 for ac_prog in comm
6185 6185 do
6186 6186 # Extract the first word of "$ac_prog", so it can be a program name with args.
6187 6187 set dummy $ac_prog; ac_word=$2
6188 6188 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6189 6189 $as_echo_n "checking for $ac_word... " >&6; }
6190 6190 if ${ac_cv_path_COMM+:} false; then :
6191 6191 $as_echo_n "(cached) " >&6
6192 6192 else
6193 6193 case $COMM in
6194 6194 [\\/]* | ?:[\\/]*)
6195 6195 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6196 6196 ;;
6197 6197 *)
6198 6198 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6199 6199 for as_dir in $PATH
6200 6200 do
6201 6201 IFS=$as_save_IFS
6202 6202 test -z "$as_dir" && as_dir=.
6203 6203 for ac_exec_ext in '' $ac_executable_extensions; do
6204 6204 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6205 6205 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6206 6206 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6207 6207 break 2
6208 6208 fi
6209 6209 done
6210 6210 done
6211 6211 IFS=$as_save_IFS
6212 6212
6213 6213 ;;
6214 6214 esac
6215 6215 fi
6216 6216 COMM=$ac_cv_path_COMM
6217 6217 if test -n "$COMM"; then
6218 6218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6219 6219 $as_echo "$COMM" >&6; }
6220 6220 else
6221 6221 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6222 6222 $as_echo "no" >&6; }
6223 6223 fi
6224 6224
6225 6225
6226 6226 test -n "$COMM" && break
6227 6227 done
6228 6228
6229 6229 else
6230 6230 # The variable is set, but is it from the command line or the environment?
6231 6231
6232 6232 # Try to remove the string !COMM! from our list.
6233 6233 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
6234 6234 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6235 6235 # If it failed, the variable was not from the command line. Ignore it,
6236 6236 # but warn the user (except for BASH, which is always set by the calling BASH).
6237 6237 if test "xCOMM" != xBASH; then
6238 6238 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
6239 6239 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
6240 6240 fi
6241 6241 # Try to locate tool using the code snippet
6242 6242 for ac_prog in comm
6243 6243 do
6244 6244 # Extract the first word of "$ac_prog", so it can be a program name with args.
6245 6245 set dummy $ac_prog; ac_word=$2
6246 6246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6247 6247 $as_echo_n "checking for $ac_word... " >&6; }
6248 6248 if ${ac_cv_path_COMM+:} false; then :
6249 6249 $as_echo_n "(cached) " >&6
6250 6250 else
6251 6251 case $COMM in
6252 6252 [\\/]* | ?:[\\/]*)
6253 6253 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6254 6254 ;;
6255 6255 *)
6256 6256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6257 6257 for as_dir in $PATH
6258 6258 do
6259 6259 IFS=$as_save_IFS
6260 6260 test -z "$as_dir" && as_dir=.
6261 6261 for ac_exec_ext in '' $ac_executable_extensions; do
6262 6262 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6263 6263 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6264 6264 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6265 6265 break 2
6266 6266 fi
6267 6267 done
6268 6268 done
6269 6269 IFS=$as_save_IFS
6270 6270
6271 6271 ;;
6272 6272 esac
6273 6273 fi
6274 6274 COMM=$ac_cv_path_COMM
6275 6275 if test -n "$COMM"; then
6276 6276 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6277 6277 $as_echo "$COMM" >&6; }
6278 6278 else
6279 6279 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6280 6280 $as_echo "no" >&6; }
6281 6281 fi
6282 6282
6283 6283
6284 6284 test -n "$COMM" && break
6285 6285 done
6286 6286
6287 6287 else
6288 6288 # If it succeeded, then it was overridden by the user. We will use it
6289 6289 # for the tool.
6290 6290
6291 6291 # First remove it from the list of overridden variables, so we can test
6292 6292 # for unknown variables in the end.
6293 6293 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6294 6294
6295 6295 # Check if we try to supply an empty value
6296 6296 if test "x$COMM" = x; then
6297 6297 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
6298 6298 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
6299 6299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6300 6300 $as_echo_n "checking for COMM... " >&6; }
6301 6301 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6302 6302 $as_echo "disabled" >&6; }
6303 6303 else
6304 6304 # Check if the provided tool contains a complete path.
6305 6305 tool_specified="$COMM"
6306 6306 tool_basename="${tool_specified##*/}"
6307 6307 if test "x$tool_basename" = "x$tool_specified"; then
6308 6308 # A command without a complete path is provided, search $PATH.
6309 6309 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
6310 6310 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
6311 6311 # Extract the first word of "$tool_basename", so it can be a program name with args.
6312 6312 set dummy $tool_basename; ac_word=$2
6313 6313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6314 6314 $as_echo_n "checking for $ac_word... " >&6; }
6315 6315 if ${ac_cv_path_COMM+:} false; then :
6316 6316 $as_echo_n "(cached) " >&6
6317 6317 else
6318 6318 case $COMM in
6319 6319 [\\/]* | ?:[\\/]*)
6320 6320 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6321 6321 ;;
6322 6322 *)
6323 6323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6324 6324 for as_dir in $PATH
6325 6325 do
6326 6326 IFS=$as_save_IFS
6327 6327 test -z "$as_dir" && as_dir=.
6328 6328 for ac_exec_ext in '' $ac_executable_extensions; do
6329 6329 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6330 6330 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6331 6331 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6332 6332 break 2
6333 6333 fi
6334 6334 done
6335 6335 done
6336 6336 IFS=$as_save_IFS
6337 6337
6338 6338 ;;
6339 6339 esac
6340 6340 fi
6341 6341 COMM=$ac_cv_path_COMM
6342 6342 if test -n "$COMM"; then
6343 6343 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6344 6344 $as_echo "$COMM" >&6; }
6345 6345 else
6346 6346 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6347 6347 $as_echo "no" >&6; }
6348 6348 fi
6349 6349
6350 6350
6351 6351 if test "x$COMM" = x; then
6352 6352 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6353 6353 fi
6354 6354 else
6355 6355 # Otherwise we believe it is a complete path. Use it as it is.
6356 6356 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
6357 6357 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
6358 6358 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6359 6359 $as_echo_n "checking for COMM... " >&6; }
6360 6360 if test ! -x "$tool_specified"; then
6361 6361 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6362 6362 $as_echo "not found" >&6; }
6363 6363 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
6364 6364 fi
6365 6365 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6366 6366 $as_echo "$tool_specified" >&6; }
6367 6367 fi
6368 6368 fi
6369 6369 fi
6370 6370
6371 6371 fi
6372 6372
6373 6373
6374 6374
6375 6375 if test "x$COMM" = x; then
6376 6376 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
6377 6377 fi
6378 6378
6379 6379
6380 6380
6381 6381
6382 6382
6383 6383 # Publish this variable in the help.
6384 6384
6385 6385
6386 6386 if [ -z "${CP+x}" ]; then
6387 6387 # The variable is not set by user, try to locate tool using the code snippet
6388 6388 for ac_prog in cp
6389 6389 do
6390 6390 # Extract the first word of "$ac_prog", so it can be a program name with args.
6391 6391 set dummy $ac_prog; ac_word=$2
6392 6392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6393 6393 $as_echo_n "checking for $ac_word... " >&6; }
6394 6394 if ${ac_cv_path_CP+:} false; then :
6395 6395 $as_echo_n "(cached) " >&6
6396 6396 else
6397 6397 case $CP in
6398 6398 [\\/]* | ?:[\\/]*)
6399 6399 ac_cv_path_CP="$CP" # Let the user override the test with a path.
6400 6400 ;;
6401 6401 *)
6402 6402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6403 6403 for as_dir in $PATH
6404 6404 do
6405 6405 IFS=$as_save_IFS
6406 6406 test -z "$as_dir" && as_dir=.
6407 6407 for ac_exec_ext in '' $ac_executable_extensions; do
6408 6408 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6409 6409 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6410 6410 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6411 6411 break 2
6412 6412 fi
6413 6413 done
6414 6414 done
6415 6415 IFS=$as_save_IFS
6416 6416
6417 6417 ;;
6418 6418 esac
6419 6419 fi
6420 6420 CP=$ac_cv_path_CP
6421 6421 if test -n "$CP"; then
6422 6422 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6423 6423 $as_echo "$CP" >&6; }
6424 6424 else
6425 6425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6426 6426 $as_echo "no" >&6; }
6427 6427 fi
6428 6428
6429 6429
6430 6430 test -n "$CP" && break
6431 6431 done
6432 6432
6433 6433 else
6434 6434 # The variable is set, but is it from the command line or the environment?
6435 6435
6436 6436 # Try to remove the string !CP! from our list.
6437 6437 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6438 6438 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6439 6439 # If it failed, the variable was not from the command line. Ignore it,
6440 6440 # but warn the user (except for BASH, which is always set by the calling BASH).
6441 6441 if test "xCP" != xBASH; then
6442 6442 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6443 6443 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6444 6444 fi
6445 6445 # Try to locate tool using the code snippet
6446 6446 for ac_prog in cp
6447 6447 do
6448 6448 # Extract the first word of "$ac_prog", so it can be a program name with args.
6449 6449 set dummy $ac_prog; ac_word=$2
6450 6450 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6451 6451 $as_echo_n "checking for $ac_word... " >&6; }
6452 6452 if ${ac_cv_path_CP+:} false; then :
6453 6453 $as_echo_n "(cached) " >&6
6454 6454 else
6455 6455 case $CP in
6456 6456 [\\/]* | ?:[\\/]*)
6457 6457 ac_cv_path_CP="$CP" # Let the user override the test with a path.
6458 6458 ;;
6459 6459 *)
6460 6460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6461 6461 for as_dir in $PATH
6462 6462 do
6463 6463 IFS=$as_save_IFS
6464 6464 test -z "$as_dir" && as_dir=.
6465 6465 for ac_exec_ext in '' $ac_executable_extensions; do
6466 6466 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6467 6467 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6468 6468 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6469 6469 break 2
6470 6470 fi
6471 6471 done
6472 6472 done
6473 6473 IFS=$as_save_IFS
6474 6474
6475 6475 ;;
6476 6476 esac
6477 6477 fi
6478 6478 CP=$ac_cv_path_CP
6479 6479 if test -n "$CP"; then
6480 6480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6481 6481 $as_echo "$CP" >&6; }
6482 6482 else
6483 6483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6484 6484 $as_echo "no" >&6; }
6485 6485 fi
6486 6486
6487 6487
6488 6488 test -n "$CP" && break
6489 6489 done
6490 6490
6491 6491 else
6492 6492 # If it succeeded, then it was overridden by the user. We will use it
6493 6493 # for the tool.
6494 6494
6495 6495 # First remove it from the list of overridden variables, so we can test
6496 6496 # for unknown variables in the end.
6497 6497 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6498 6498
6499 6499 # Check if we try to supply an empty value
6500 6500 if test "x$CP" = x; then
6501 6501 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6502 6502 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6503 6503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6504 6504 $as_echo_n "checking for CP... " >&6; }
6505 6505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6506 6506 $as_echo "disabled" >&6; }
6507 6507 else
6508 6508 # Check if the provided tool contains a complete path.
6509 6509 tool_specified="$CP"
6510 6510 tool_basename="${tool_specified##*/}"
6511 6511 if test "x$tool_basename" = "x$tool_specified"; then
6512 6512 # A command without a complete path is provided, search $PATH.
6513 6513 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6514 6514 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6515 6515 # Extract the first word of "$tool_basename", so it can be a program name with args.
6516 6516 set dummy $tool_basename; ac_word=$2
6517 6517 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6518 6518 $as_echo_n "checking for $ac_word... " >&6; }
6519 6519 if ${ac_cv_path_CP+:} false; then :
6520 6520 $as_echo_n "(cached) " >&6
6521 6521 else
6522 6522 case $CP in
6523 6523 [\\/]* | ?:[\\/]*)
6524 6524 ac_cv_path_CP="$CP" # Let the user override the test with a path.
6525 6525 ;;
6526 6526 *)
6527 6527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6528 6528 for as_dir in $PATH
6529 6529 do
6530 6530 IFS=$as_save_IFS
6531 6531 test -z "$as_dir" && as_dir=.
6532 6532 for ac_exec_ext in '' $ac_executable_extensions; do
6533 6533 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6534 6534 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6535 6535 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6536 6536 break 2
6537 6537 fi
6538 6538 done
6539 6539 done
6540 6540 IFS=$as_save_IFS
6541 6541
6542 6542 ;;
6543 6543 esac
6544 6544 fi
6545 6545 CP=$ac_cv_path_CP
6546 6546 if test -n "$CP"; then
6547 6547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6548 6548 $as_echo "$CP" >&6; }
6549 6549 else
6550 6550 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6551 6551 $as_echo "no" >&6; }
6552 6552 fi
6553 6553
6554 6554
6555 6555 if test "x$CP" = x; then
6556 6556 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6557 6557 fi
6558 6558 else
6559 6559 # Otherwise we believe it is a complete path. Use it as it is.
6560 6560 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6561 6561 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6562 6562 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6563 6563 $as_echo_n "checking for CP... " >&6; }
6564 6564 if test ! -x "$tool_specified"; then
6565 6565 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6566 6566 $as_echo "not found" >&6; }
6567 6567 as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6568 6568 fi
6569 6569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6570 6570 $as_echo "$tool_specified" >&6; }
6571 6571 fi
6572 6572 fi
6573 6573 fi
6574 6574
6575 6575 fi
6576 6576
6577 6577
6578 6578
6579 6579 if test "x$CP" = x; then
6580 6580 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6581 6581 fi
6582 6582
6583 6583
6584 6584
6585 6585
6586 6586
6587 6587 # Publish this variable in the help.
6588 6588
6589 6589
6590 6590 if [ -z "${CUT+x}" ]; then
6591 6591 # The variable is not set by user, try to locate tool using the code snippet
6592 6592 for ac_prog in cut
6593 6593 do
6594 6594 # Extract the first word of "$ac_prog", so it can be a program name with args.
6595 6595 set dummy $ac_prog; ac_word=$2
6596 6596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6597 6597 $as_echo_n "checking for $ac_word... " >&6; }
6598 6598 if ${ac_cv_path_CUT+:} false; then :
6599 6599 $as_echo_n "(cached) " >&6
6600 6600 else
6601 6601 case $CUT in
6602 6602 [\\/]* | ?:[\\/]*)
6603 6603 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6604 6604 ;;
6605 6605 *)
6606 6606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 6607 for as_dir in $PATH
6608 6608 do
6609 6609 IFS=$as_save_IFS
6610 6610 test -z "$as_dir" && as_dir=.
6611 6611 for ac_exec_ext in '' $ac_executable_extensions; do
6612 6612 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613 6613 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6614 6614 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6615 6615 break 2
6616 6616 fi
6617 6617 done
6618 6618 done
6619 6619 IFS=$as_save_IFS
6620 6620
6621 6621 ;;
6622 6622 esac
6623 6623 fi
6624 6624 CUT=$ac_cv_path_CUT
6625 6625 if test -n "$CUT"; then
6626 6626 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6627 6627 $as_echo "$CUT" >&6; }
6628 6628 else
6629 6629 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6630 6630 $as_echo "no" >&6; }
6631 6631 fi
6632 6632
6633 6633
6634 6634 test -n "$CUT" && break
6635 6635 done
6636 6636
6637 6637 else
6638 6638 # The variable is set, but is it from the command line or the environment?
6639 6639
6640 6640 # Try to remove the string !CUT! from our list.
6641 6641 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6642 6642 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6643 6643 # If it failed, the variable was not from the command line. Ignore it,
6644 6644 # but warn the user (except for BASH, which is always set by the calling BASH).
6645 6645 if test "xCUT" != xBASH; then
6646 6646 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6647 6647 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6648 6648 fi
6649 6649 # Try to locate tool using the code snippet
6650 6650 for ac_prog in cut
6651 6651 do
6652 6652 # Extract the first word of "$ac_prog", so it can be a program name with args.
6653 6653 set dummy $ac_prog; ac_word=$2
6654 6654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6655 6655 $as_echo_n "checking for $ac_word... " >&6; }
6656 6656 if ${ac_cv_path_CUT+:} false; then :
6657 6657 $as_echo_n "(cached) " >&6
6658 6658 else
6659 6659 case $CUT in
6660 6660 [\\/]* | ?:[\\/]*)
6661 6661 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6662 6662 ;;
6663 6663 *)
6664 6664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 6665 for as_dir in $PATH
6666 6666 do
6667 6667 IFS=$as_save_IFS
6668 6668 test -z "$as_dir" && as_dir=.
6669 6669 for ac_exec_ext in '' $ac_executable_extensions; do
6670 6670 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671 6671 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6672 6672 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6673 6673 break 2
6674 6674 fi
6675 6675 done
6676 6676 done
6677 6677 IFS=$as_save_IFS
6678 6678
6679 6679 ;;
6680 6680 esac
6681 6681 fi
6682 6682 CUT=$ac_cv_path_CUT
6683 6683 if test -n "$CUT"; then
6684 6684 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6685 6685 $as_echo "$CUT" >&6; }
6686 6686 else
6687 6687 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6688 6688 $as_echo "no" >&6; }
6689 6689 fi
6690 6690
6691 6691
6692 6692 test -n "$CUT" && break
6693 6693 done
6694 6694
6695 6695 else
6696 6696 # If it succeeded, then it was overridden by the user. We will use it
6697 6697 # for the tool.
6698 6698
6699 6699 # First remove it from the list of overridden variables, so we can test
6700 6700 # for unknown variables in the end.
6701 6701 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6702 6702
6703 6703 # Check if we try to supply an empty value
6704 6704 if test "x$CUT" = x; then
6705 6705 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6706 6706 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6707 6707 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6708 6708 $as_echo_n "checking for CUT... " >&6; }
6709 6709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6710 6710 $as_echo "disabled" >&6; }
6711 6711 else
6712 6712 # Check if the provided tool contains a complete path.
6713 6713 tool_specified="$CUT"
6714 6714 tool_basename="${tool_specified##*/}"
6715 6715 if test "x$tool_basename" = "x$tool_specified"; then
6716 6716 # A command without a complete path is provided, search $PATH.
6717 6717 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6718 6718 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6719 6719 # Extract the first word of "$tool_basename", so it can be a program name with args.
6720 6720 set dummy $tool_basename; ac_word=$2
6721 6721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6722 6722 $as_echo_n "checking for $ac_word... " >&6; }
6723 6723 if ${ac_cv_path_CUT+:} false; then :
6724 6724 $as_echo_n "(cached) " >&6
6725 6725 else
6726 6726 case $CUT in
6727 6727 [\\/]* | ?:[\\/]*)
6728 6728 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6729 6729 ;;
6730 6730 *)
6731 6731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6732 6732 for as_dir in $PATH
6733 6733 do
6734 6734 IFS=$as_save_IFS
6735 6735 test -z "$as_dir" && as_dir=.
6736 6736 for ac_exec_ext in '' $ac_executable_extensions; do
6737 6737 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6738 6738 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6739 6739 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6740 6740 break 2
6741 6741 fi
6742 6742 done
6743 6743 done
6744 6744 IFS=$as_save_IFS
6745 6745
6746 6746 ;;
6747 6747 esac
6748 6748 fi
6749 6749 CUT=$ac_cv_path_CUT
6750 6750 if test -n "$CUT"; then
6751 6751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6752 6752 $as_echo "$CUT" >&6; }
6753 6753 else
6754 6754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6755 6755 $as_echo "no" >&6; }
6756 6756 fi
6757 6757
6758 6758
6759 6759 if test "x$CUT" = x; then
6760 6760 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6761 6761 fi
6762 6762 else
6763 6763 # Otherwise we believe it is a complete path. Use it as it is.
6764 6764 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6765 6765 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6766 6766 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6767 6767 $as_echo_n "checking for CUT... " >&6; }
6768 6768 if test ! -x "$tool_specified"; then
6769 6769 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6770 6770 $as_echo "not found" >&6; }
6771 6771 as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6772 6772 fi
6773 6773 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6774 6774 $as_echo "$tool_specified" >&6; }
6775 6775 fi
6776 6776 fi
6777 6777 fi
6778 6778
6779 6779 fi
6780 6780
6781 6781
6782 6782
6783 6783 if test "x$CUT" = x; then
6784 6784 as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6785 6785 fi
6786 6786
6787 6787
6788 6788
6789 6789
6790 6790
6791 6791 # Publish this variable in the help.
6792 6792
6793 6793
6794 6794 if [ -z "${DATE+x}" ]; then
6795 6795 # The variable is not set by user, try to locate tool using the code snippet
6796 6796 for ac_prog in date
6797 6797 do
6798 6798 # Extract the first word of "$ac_prog", so it can be a program name with args.
6799 6799 set dummy $ac_prog; ac_word=$2
6800 6800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6801 6801 $as_echo_n "checking for $ac_word... " >&6; }
6802 6802 if ${ac_cv_path_DATE+:} false; then :
6803 6803 $as_echo_n "(cached) " >&6
6804 6804 else
6805 6805 case $DATE in
6806 6806 [\\/]* | ?:[\\/]*)
6807 6807 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6808 6808 ;;
6809 6809 *)
6810 6810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6811 6811 for as_dir in $PATH
6812 6812 do
6813 6813 IFS=$as_save_IFS
6814 6814 test -z "$as_dir" && as_dir=.
6815 6815 for ac_exec_ext in '' $ac_executable_extensions; do
6816 6816 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6817 6817 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6818 6818 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6819 6819 break 2
6820 6820 fi
6821 6821 done
6822 6822 done
6823 6823 IFS=$as_save_IFS
6824 6824
6825 6825 ;;
6826 6826 esac
6827 6827 fi
6828 6828 DATE=$ac_cv_path_DATE
6829 6829 if test -n "$DATE"; then
6830 6830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6831 6831 $as_echo "$DATE" >&6; }
6832 6832 else
6833 6833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6834 6834 $as_echo "no" >&6; }
6835 6835 fi
6836 6836
6837 6837
6838 6838 test -n "$DATE" && break
6839 6839 done
6840 6840
6841 6841 else
6842 6842 # The variable is set, but is it from the command line or the environment?
6843 6843
6844 6844 # Try to remove the string !DATE! from our list.
6845 6845 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6846 6846 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6847 6847 # If it failed, the variable was not from the command line. Ignore it,
6848 6848 # but warn the user (except for BASH, which is always set by the calling BASH).
6849 6849 if test "xDATE" != xBASH; then
6850 6850 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6851 6851 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6852 6852 fi
6853 6853 # Try to locate tool using the code snippet
6854 6854 for ac_prog in date
6855 6855 do
6856 6856 # Extract the first word of "$ac_prog", so it can be a program name with args.
6857 6857 set dummy $ac_prog; ac_word=$2
6858 6858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6859 6859 $as_echo_n "checking for $ac_word... " >&6; }
6860 6860 if ${ac_cv_path_DATE+:} false; then :
6861 6861 $as_echo_n "(cached) " >&6
6862 6862 else
6863 6863 case $DATE in
6864 6864 [\\/]* | ?:[\\/]*)
6865 6865 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6866 6866 ;;
6867 6867 *)
6868 6868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6869 6869 for as_dir in $PATH
6870 6870 do
6871 6871 IFS=$as_save_IFS
6872 6872 test -z "$as_dir" && as_dir=.
6873 6873 for ac_exec_ext in '' $ac_executable_extensions; do
6874 6874 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6875 6875 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6876 6876 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6877 6877 break 2
6878 6878 fi
6879 6879 done
6880 6880 done
6881 6881 IFS=$as_save_IFS
6882 6882
6883 6883 ;;
6884 6884 esac
6885 6885 fi
6886 6886 DATE=$ac_cv_path_DATE
6887 6887 if test -n "$DATE"; then
6888 6888 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6889 6889 $as_echo "$DATE" >&6; }
6890 6890 else
6891 6891 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6892 6892 $as_echo "no" >&6; }
6893 6893 fi
6894 6894
6895 6895
6896 6896 test -n "$DATE" && break
6897 6897 done
6898 6898
6899 6899 else
6900 6900 # If it succeeded, then it was overridden by the user. We will use it
6901 6901 # for the tool.
6902 6902
6903 6903 # First remove it from the list of overridden variables, so we can test
6904 6904 # for unknown variables in the end.
6905 6905 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6906 6906
6907 6907 # Check if we try to supply an empty value
6908 6908 if test "x$DATE" = x; then
6909 6909 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6910 6910 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6911 6911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6912 6912 $as_echo_n "checking for DATE... " >&6; }
6913 6913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6914 6914 $as_echo "disabled" >&6; }
6915 6915 else
6916 6916 # Check if the provided tool contains a complete path.
6917 6917 tool_specified="$DATE"
6918 6918 tool_basename="${tool_specified##*/}"
6919 6919 if test "x$tool_basename" = "x$tool_specified"; then
6920 6920 # A command without a complete path is provided, search $PATH.
6921 6921 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6922 6922 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6923 6923 # Extract the first word of "$tool_basename", so it can be a program name with args.
6924 6924 set dummy $tool_basename; ac_word=$2
6925 6925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6926 6926 $as_echo_n "checking for $ac_word... " >&6; }
6927 6927 if ${ac_cv_path_DATE+:} false; then :
6928 6928 $as_echo_n "(cached) " >&6
6929 6929 else
6930 6930 case $DATE in
6931 6931 [\\/]* | ?:[\\/]*)
6932 6932 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6933 6933 ;;
6934 6934 *)
6935 6935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6936 6936 for as_dir in $PATH
6937 6937 do
6938 6938 IFS=$as_save_IFS
6939 6939 test -z "$as_dir" && as_dir=.
6940 6940 for ac_exec_ext in '' $ac_executable_extensions; do
6941 6941 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6942 6942 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6943 6943 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6944 6944 break 2
6945 6945 fi
6946 6946 done
6947 6947 done
6948 6948 IFS=$as_save_IFS
6949 6949
6950 6950 ;;
6951 6951 esac
6952 6952 fi
6953 6953 DATE=$ac_cv_path_DATE
6954 6954 if test -n "$DATE"; then
6955 6955 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6956 6956 $as_echo "$DATE" >&6; }
6957 6957 else
6958 6958 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6959 6959 $as_echo "no" >&6; }
6960 6960 fi
6961 6961
6962 6962
6963 6963 if test "x$DATE" = x; then
6964 6964 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6965 6965 fi
6966 6966 else
6967 6967 # Otherwise we believe it is a complete path. Use it as it is.
6968 6968 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6969 6969 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6970 6970 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6971 6971 $as_echo_n "checking for DATE... " >&6; }
6972 6972 if test ! -x "$tool_specified"; then
6973 6973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6974 6974 $as_echo "not found" >&6; }
6975 6975 as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6976 6976 fi
6977 6977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6978 6978 $as_echo "$tool_specified" >&6; }
6979 6979 fi
6980 6980 fi
6981 6981 fi
6982 6982
6983 6983 fi
6984 6984
6985 6985
6986 6986
6987 6987 if test "x$DATE" = x; then
6988 6988 as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6989 6989 fi
6990 6990
6991 6991
6992 6992
6993 6993
6994 6994
6995 6995 # Publish this variable in the help.
6996 6996
6997 6997
6998 6998 if [ -z "${DIFF+x}" ]; then
6999 6999 # The variable is not set by user, try to locate tool using the code snippet
7000 7000 for ac_prog in gdiff diff
7001 7001 do
7002 7002 # Extract the first word of "$ac_prog", so it can be a program name with args.
7003 7003 set dummy $ac_prog; ac_word=$2
7004 7004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7005 7005 $as_echo_n "checking for $ac_word... " >&6; }
7006 7006 if ${ac_cv_path_DIFF+:} false; then :
7007 7007 $as_echo_n "(cached) " >&6
7008 7008 else
7009 7009 case $DIFF in
7010 7010 [\\/]* | ?:[\\/]*)
7011 7011 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7012 7012 ;;
7013 7013 *)
7014 7014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7015 7015 for as_dir in $PATH
7016 7016 do
7017 7017 IFS=$as_save_IFS
7018 7018 test -z "$as_dir" && as_dir=.
7019 7019 for ac_exec_ext in '' $ac_executable_extensions; do
7020 7020 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7021 7021 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7022 7022 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7023 7023 break 2
7024 7024 fi
7025 7025 done
7026 7026 done
7027 7027 IFS=$as_save_IFS
7028 7028
7029 7029 ;;
7030 7030 esac
7031 7031 fi
7032 7032 DIFF=$ac_cv_path_DIFF
7033 7033 if test -n "$DIFF"; then
7034 7034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7035 7035 $as_echo "$DIFF" >&6; }
7036 7036 else
7037 7037 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7038 7038 $as_echo "no" >&6; }
7039 7039 fi
7040 7040
7041 7041
7042 7042 test -n "$DIFF" && break
7043 7043 done
7044 7044
7045 7045 else
7046 7046 # The variable is set, but is it from the command line or the environment?
7047 7047
7048 7048 # Try to remove the string !DIFF! from our list.
7049 7049 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
7050 7050 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7051 7051 # If it failed, the variable was not from the command line. Ignore it,
7052 7052 # but warn the user (except for BASH, which is always set by the calling BASH).
7053 7053 if test "xDIFF" != xBASH; then
7054 7054 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
7055 7055 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
7056 7056 fi
7057 7057 # Try to locate tool using the code snippet
7058 7058 for ac_prog in gdiff diff
7059 7059 do
7060 7060 # Extract the first word of "$ac_prog", so it can be a program name with args.
7061 7061 set dummy $ac_prog; ac_word=$2
7062 7062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7063 7063 $as_echo_n "checking for $ac_word... " >&6; }
7064 7064 if ${ac_cv_path_DIFF+:} false; then :
7065 7065 $as_echo_n "(cached) " >&6
7066 7066 else
7067 7067 case $DIFF in
7068 7068 [\\/]* | ?:[\\/]*)
7069 7069 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7070 7070 ;;
7071 7071 *)
7072 7072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7073 7073 for as_dir in $PATH
7074 7074 do
7075 7075 IFS=$as_save_IFS
7076 7076 test -z "$as_dir" && as_dir=.
7077 7077 for ac_exec_ext in '' $ac_executable_extensions; do
7078 7078 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7079 7079 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7080 7080 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7081 7081 break 2
7082 7082 fi
7083 7083 done
7084 7084 done
7085 7085 IFS=$as_save_IFS
7086 7086
7087 7087 ;;
7088 7088 esac
7089 7089 fi
7090 7090 DIFF=$ac_cv_path_DIFF
7091 7091 if test -n "$DIFF"; then
7092 7092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7093 7093 $as_echo "$DIFF" >&6; }
7094 7094 else
7095 7095 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7096 7096 $as_echo "no" >&6; }
7097 7097 fi
7098 7098
7099 7099
7100 7100 test -n "$DIFF" && break
7101 7101 done
7102 7102
7103 7103 else
7104 7104 # If it succeeded, then it was overridden by the user. We will use it
7105 7105 # for the tool.
7106 7106
7107 7107 # First remove it from the list of overridden variables, so we can test
7108 7108 # for unknown variables in the end.
7109 7109 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7110 7110
7111 7111 # Check if we try to supply an empty value
7112 7112 if test "x$DIFF" = x; then
7113 7113 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
7114 7114 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
7115 7115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7116 7116 $as_echo_n "checking for DIFF... " >&6; }
7117 7117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7118 7118 $as_echo "disabled" >&6; }
7119 7119 else
7120 7120 # Check if the provided tool contains a complete path.
7121 7121 tool_specified="$DIFF"
7122 7122 tool_basename="${tool_specified##*/}"
7123 7123 if test "x$tool_basename" = "x$tool_specified"; then
7124 7124 # A command without a complete path is provided, search $PATH.
7125 7125 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
7126 7126 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
7127 7127 # Extract the first word of "$tool_basename", so it can be a program name with args.
7128 7128 set dummy $tool_basename; ac_word=$2
7129 7129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7130 7130 $as_echo_n "checking for $ac_word... " >&6; }
7131 7131 if ${ac_cv_path_DIFF+:} false; then :
7132 7132 $as_echo_n "(cached) " >&6
7133 7133 else
7134 7134 case $DIFF in
7135 7135 [\\/]* | ?:[\\/]*)
7136 7136 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7137 7137 ;;
7138 7138 *)
7139 7139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7140 7140 for as_dir in $PATH
7141 7141 do
7142 7142 IFS=$as_save_IFS
7143 7143 test -z "$as_dir" && as_dir=.
7144 7144 for ac_exec_ext in '' $ac_executable_extensions; do
7145 7145 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7146 7146 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7147 7147 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7148 7148 break 2
7149 7149 fi
7150 7150 done
7151 7151 done
7152 7152 IFS=$as_save_IFS
7153 7153
7154 7154 ;;
7155 7155 esac
7156 7156 fi
7157 7157 DIFF=$ac_cv_path_DIFF
7158 7158 if test -n "$DIFF"; then
7159 7159 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7160 7160 $as_echo "$DIFF" >&6; }
7161 7161 else
7162 7162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7163 7163 $as_echo "no" >&6; }
7164 7164 fi
7165 7165
7166 7166
7167 7167 if test "x$DIFF" = x; then
7168 7168 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7169 7169 fi
7170 7170 else
7171 7171 # Otherwise we believe it is a complete path. Use it as it is.
7172 7172 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
7173 7173 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
7174 7174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7175 7175 $as_echo_n "checking for DIFF... " >&6; }
7176 7176 if test ! -x "$tool_specified"; then
7177 7177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7178 7178 $as_echo "not found" >&6; }
7179 7179 as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
7180 7180 fi
7181 7181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7182 7182 $as_echo "$tool_specified" >&6; }
7183 7183 fi
7184 7184 fi
7185 7185 fi
7186 7186
7187 7187 fi
7188 7188
7189 7189
7190 7190
7191 7191 if test "x$DIFF" = x; then
7192 7192 as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
7193 7193 fi
7194 7194
7195 7195
7196 7196
7197 7197
7198 7198
7199 7199 # Publish this variable in the help.
7200 7200
7201 7201
7202 7202 if [ -z "${DIRNAME+x}" ]; then
7203 7203 # The variable is not set by user, try to locate tool using the code snippet
7204 7204 for ac_prog in dirname
7205 7205 do
7206 7206 # Extract the first word of "$ac_prog", so it can be a program name with args.
7207 7207 set dummy $ac_prog; ac_word=$2
7208 7208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7209 7209 $as_echo_n "checking for $ac_word... " >&6; }
7210 7210 if ${ac_cv_path_DIRNAME+:} false; then :
7211 7211 $as_echo_n "(cached) " >&6
7212 7212 else
7213 7213 case $DIRNAME in
7214 7214 [\\/]* | ?:[\\/]*)
7215 7215 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7216 7216 ;;
7217 7217 *)
7218 7218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7219 7219 for as_dir in $PATH
7220 7220 do
7221 7221 IFS=$as_save_IFS
7222 7222 test -z "$as_dir" && as_dir=.
7223 7223 for ac_exec_ext in '' $ac_executable_extensions; do
7224 7224 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7225 7225 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7226 7226 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7227 7227 break 2
7228 7228 fi
7229 7229 done
7230 7230 done
7231 7231 IFS=$as_save_IFS
7232 7232
7233 7233 ;;
7234 7234 esac
7235 7235 fi
7236 7236 DIRNAME=$ac_cv_path_DIRNAME
7237 7237 if test -n "$DIRNAME"; then
7238 7238 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7239 7239 $as_echo "$DIRNAME" >&6; }
7240 7240 else
7241 7241 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7242 7242 $as_echo "no" >&6; }
7243 7243 fi
7244 7244
7245 7245
7246 7246 test -n "$DIRNAME" && break
7247 7247 done
7248 7248
7249 7249 else
7250 7250 # The variable is set, but is it from the command line or the environment?
7251 7251
7252 7252 # Try to remove the string !DIRNAME! from our list.
7253 7253 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
7254 7254 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7255 7255 # If it failed, the variable was not from the command line. Ignore it,
7256 7256 # but warn the user (except for BASH, which is always set by the calling BASH).
7257 7257 if test "xDIRNAME" != xBASH; then
7258 7258 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
7259 7259 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
7260 7260 fi
7261 7261 # Try to locate tool using the code snippet
7262 7262 for ac_prog in dirname
7263 7263 do
7264 7264 # Extract the first word of "$ac_prog", so it can be a program name with args.
7265 7265 set dummy $ac_prog; ac_word=$2
7266 7266 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7267 7267 $as_echo_n "checking for $ac_word... " >&6; }
7268 7268 if ${ac_cv_path_DIRNAME+:} false; then :
7269 7269 $as_echo_n "(cached) " >&6
7270 7270 else
7271 7271 case $DIRNAME in
7272 7272 [\\/]* | ?:[\\/]*)
7273 7273 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7274 7274 ;;
7275 7275 *)
7276 7276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7277 7277 for as_dir in $PATH
7278 7278 do
7279 7279 IFS=$as_save_IFS
7280 7280 test -z "$as_dir" && as_dir=.
7281 7281 for ac_exec_ext in '' $ac_executable_extensions; do
7282 7282 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7283 7283 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7284 7284 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7285 7285 break 2
7286 7286 fi
7287 7287 done
7288 7288 done
7289 7289 IFS=$as_save_IFS
7290 7290
7291 7291 ;;
7292 7292 esac
7293 7293 fi
7294 7294 DIRNAME=$ac_cv_path_DIRNAME
7295 7295 if test -n "$DIRNAME"; then
7296 7296 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7297 7297 $as_echo "$DIRNAME" >&6; }
7298 7298 else
7299 7299 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7300 7300 $as_echo "no" >&6; }
7301 7301 fi
7302 7302
7303 7303
7304 7304 test -n "$DIRNAME" && break
7305 7305 done
7306 7306
7307 7307 else
7308 7308 # If it succeeded, then it was overridden by the user. We will use it
7309 7309 # for the tool.
7310 7310
7311 7311 # First remove it from the list of overridden variables, so we can test
7312 7312 # for unknown variables in the end.
7313 7313 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7314 7314
7315 7315 # Check if we try to supply an empty value
7316 7316 if test "x$DIRNAME" = x; then
7317 7317 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
7318 7318 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
7319 7319 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7320 7320 $as_echo_n "checking for DIRNAME... " >&6; }
7321 7321 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7322 7322 $as_echo "disabled" >&6; }
7323 7323 else
7324 7324 # Check if the provided tool contains a complete path.
7325 7325 tool_specified="$DIRNAME"
7326 7326 tool_basename="${tool_specified##*/}"
7327 7327 if test "x$tool_basename" = "x$tool_specified"; then
7328 7328 # A command without a complete path is provided, search $PATH.
7329 7329 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
7330 7330 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
7331 7331 # Extract the first word of "$tool_basename", so it can be a program name with args.
7332 7332 set dummy $tool_basename; ac_word=$2
7333 7333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7334 7334 $as_echo_n "checking for $ac_word... " >&6; }
7335 7335 if ${ac_cv_path_DIRNAME+:} false; then :
7336 7336 $as_echo_n "(cached) " >&6
7337 7337 else
7338 7338 case $DIRNAME in
7339 7339 [\\/]* | ?:[\\/]*)
7340 7340 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7341 7341 ;;
7342 7342 *)
7343 7343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7344 7344 for as_dir in $PATH
7345 7345 do
7346 7346 IFS=$as_save_IFS
7347 7347 test -z "$as_dir" && as_dir=.
7348 7348 for ac_exec_ext in '' $ac_executable_extensions; do
7349 7349 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7350 7350 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7351 7351 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7352 7352 break 2
7353 7353 fi
7354 7354 done
7355 7355 done
7356 7356 IFS=$as_save_IFS
7357 7357
7358 7358 ;;
7359 7359 esac
7360 7360 fi
7361 7361 DIRNAME=$ac_cv_path_DIRNAME
7362 7362 if test -n "$DIRNAME"; then
7363 7363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7364 7364 $as_echo "$DIRNAME" >&6; }
7365 7365 else
7366 7366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7367 7367 $as_echo "no" >&6; }
7368 7368 fi
7369 7369
7370 7370
7371 7371 if test "x$DIRNAME" = x; then
7372 7372 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7373 7373 fi
7374 7374 else
7375 7375 # Otherwise we believe it is a complete path. Use it as it is.
7376 7376 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
7377 7377 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
7378 7378 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7379 7379 $as_echo_n "checking for DIRNAME... " >&6; }
7380 7380 if test ! -x "$tool_specified"; then
7381 7381 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7382 7382 $as_echo "not found" >&6; }
7383 7383 as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
7384 7384 fi
7385 7385 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7386 7386 $as_echo "$tool_specified" >&6; }
7387 7387 fi
7388 7388 fi
7389 7389 fi
7390 7390
7391 7391 fi
7392 7392
7393 7393
7394 7394
7395 7395 if test "x$DIRNAME" = x; then
7396 7396 as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7397 7397 fi
7398 7398
7399 7399
7400 7400
7401 7401
7402 7402
7403 7403 # Publish this variable in the help.
7404 7404
7405 7405
7406 7406 if [ -z "${ECHO+x}" ]; then
7407 7407 # The variable is not set by user, try to locate tool using the code snippet
7408 7408 for ac_prog in echo
7409 7409 do
7410 7410 # Extract the first word of "$ac_prog", so it can be a program name with args.
7411 7411 set dummy $ac_prog; ac_word=$2
7412 7412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7413 7413 $as_echo_n "checking for $ac_word... " >&6; }
7414 7414 if ${ac_cv_path_ECHO+:} false; then :
7415 7415 $as_echo_n "(cached) " >&6
7416 7416 else
7417 7417 case $ECHO in
7418 7418 [\\/]* | ?:[\\/]*)
7419 7419 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7420 7420 ;;
7421 7421 *)
7422 7422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7423 7423 for as_dir in $PATH
7424 7424 do
7425 7425 IFS=$as_save_IFS
7426 7426 test -z "$as_dir" && as_dir=.
7427 7427 for ac_exec_ext in '' $ac_executable_extensions; do
7428 7428 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7429 7429 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7430 7430 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7431 7431 break 2
7432 7432 fi
7433 7433 done
7434 7434 done
7435 7435 IFS=$as_save_IFS
7436 7436
7437 7437 ;;
7438 7438 esac
7439 7439 fi
7440 7440 ECHO=$ac_cv_path_ECHO
7441 7441 if test -n "$ECHO"; then
7442 7442 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7443 7443 $as_echo "$ECHO" >&6; }
7444 7444 else
7445 7445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7446 7446 $as_echo "no" >&6; }
7447 7447 fi
7448 7448
7449 7449
7450 7450 test -n "$ECHO" && break
7451 7451 done
7452 7452
7453 7453 else
7454 7454 # The variable is set, but is it from the command line or the environment?
7455 7455
7456 7456 # Try to remove the string !ECHO! from our list.
7457 7457 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7458 7458 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7459 7459 # If it failed, the variable was not from the command line. Ignore it,
7460 7460 # but warn the user (except for BASH, which is always set by the calling BASH).
7461 7461 if test "xECHO" != xBASH; then
7462 7462 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7463 7463 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7464 7464 fi
7465 7465 # Try to locate tool using the code snippet
7466 7466 for ac_prog in echo
7467 7467 do
7468 7468 # Extract the first word of "$ac_prog", so it can be a program name with args.
7469 7469 set dummy $ac_prog; ac_word=$2
7470 7470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7471 7471 $as_echo_n "checking for $ac_word... " >&6; }
7472 7472 if ${ac_cv_path_ECHO+:} false; then :
7473 7473 $as_echo_n "(cached) " >&6
7474 7474 else
7475 7475 case $ECHO in
7476 7476 [\\/]* | ?:[\\/]*)
7477 7477 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7478 7478 ;;
7479 7479 *)
7480 7480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 7481 for as_dir in $PATH
7482 7482 do
7483 7483 IFS=$as_save_IFS
7484 7484 test -z "$as_dir" && as_dir=.
7485 7485 for ac_exec_ext in '' $ac_executable_extensions; do
7486 7486 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487 7487 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7488 7488 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7489 7489 break 2
7490 7490 fi
7491 7491 done
7492 7492 done
7493 7493 IFS=$as_save_IFS
7494 7494
7495 7495 ;;
7496 7496 esac
7497 7497 fi
7498 7498 ECHO=$ac_cv_path_ECHO
7499 7499 if test -n "$ECHO"; then
7500 7500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7501 7501 $as_echo "$ECHO" >&6; }
7502 7502 else
7503 7503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7504 7504 $as_echo "no" >&6; }
7505 7505 fi
7506 7506
7507 7507
7508 7508 test -n "$ECHO" && break
7509 7509 done
7510 7510
7511 7511 else
7512 7512 # If it succeeded, then it was overridden by the user. We will use it
7513 7513 # for the tool.
7514 7514
7515 7515 # First remove it from the list of overridden variables, so we can test
7516 7516 # for unknown variables in the end.
7517 7517 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7518 7518
7519 7519 # Check if we try to supply an empty value
7520 7520 if test "x$ECHO" = x; then
7521 7521 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7522 7522 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7523 7523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7524 7524 $as_echo_n "checking for ECHO... " >&6; }
7525 7525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7526 7526 $as_echo "disabled" >&6; }
7527 7527 else
7528 7528 # Check if the provided tool contains a complete path.
7529 7529 tool_specified="$ECHO"
7530 7530 tool_basename="${tool_specified##*/}"
7531 7531 if test "x$tool_basename" = "x$tool_specified"; then
7532 7532 # A command without a complete path is provided, search $PATH.
7533 7533 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7534 7534 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7535 7535 # Extract the first word of "$tool_basename", so it can be a program name with args.
7536 7536 set dummy $tool_basename; ac_word=$2
7537 7537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7538 7538 $as_echo_n "checking for $ac_word... " >&6; }
7539 7539 if ${ac_cv_path_ECHO+:} false; then :
7540 7540 $as_echo_n "(cached) " >&6
7541 7541 else
7542 7542 case $ECHO in
7543 7543 [\\/]* | ?:[\\/]*)
7544 7544 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7545 7545 ;;
7546 7546 *)
7547 7547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7548 7548 for as_dir in $PATH
7549 7549 do
7550 7550 IFS=$as_save_IFS
7551 7551 test -z "$as_dir" && as_dir=.
7552 7552 for ac_exec_ext in '' $ac_executable_extensions; do
7553 7553 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7554 7554 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7555 7555 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7556 7556 break 2
7557 7557 fi
7558 7558 done
7559 7559 done
7560 7560 IFS=$as_save_IFS
7561 7561
7562 7562 ;;
7563 7563 esac
7564 7564 fi
7565 7565 ECHO=$ac_cv_path_ECHO
7566 7566 if test -n "$ECHO"; then
7567 7567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7568 7568 $as_echo "$ECHO" >&6; }
7569 7569 else
7570 7570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7571 7571 $as_echo "no" >&6; }
7572 7572 fi
7573 7573
7574 7574
7575 7575 if test "x$ECHO" = x; then
7576 7576 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7577 7577 fi
7578 7578 else
7579 7579 # Otherwise we believe it is a complete path. Use it as it is.
7580 7580 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7581 7581 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7582 7582 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7583 7583 $as_echo_n "checking for ECHO... " >&6; }
7584 7584 if test ! -x "$tool_specified"; then
7585 7585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7586 7586 $as_echo "not found" >&6; }
7587 7587 as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7588 7588 fi
7589 7589 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7590 7590 $as_echo "$tool_specified" >&6; }
7591 7591 fi
7592 7592 fi
7593 7593 fi
7594 7594
7595 7595 fi
7596 7596
7597 7597
7598 7598
7599 7599 if test "x$ECHO" = x; then
7600 7600 as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7601 7601 fi
7602 7602
7603 7603
7604 7604
7605 7605
7606 7606
7607 7607 # Publish this variable in the help.
7608 7608
7609 7609
7610 7610 if [ -z "${EXPR+x}" ]; then
7611 7611 # The variable is not set by user, try to locate tool using the code snippet
7612 7612 for ac_prog in expr
7613 7613 do
7614 7614 # Extract the first word of "$ac_prog", so it can be a program name with args.
7615 7615 set dummy $ac_prog; ac_word=$2
7616 7616 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7617 7617 $as_echo_n "checking for $ac_word... " >&6; }
7618 7618 if ${ac_cv_path_EXPR+:} false; then :
7619 7619 $as_echo_n "(cached) " >&6
7620 7620 else
7621 7621 case $EXPR in
7622 7622 [\\/]* | ?:[\\/]*)
7623 7623 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7624 7624 ;;
7625 7625 *)
7626 7626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7627 7627 for as_dir in $PATH
7628 7628 do
7629 7629 IFS=$as_save_IFS
7630 7630 test -z "$as_dir" && as_dir=.
7631 7631 for ac_exec_ext in '' $ac_executable_extensions; do
7632 7632 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7633 7633 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7634 7634 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7635 7635 break 2
7636 7636 fi
7637 7637 done
7638 7638 done
7639 7639 IFS=$as_save_IFS
7640 7640
7641 7641 ;;
7642 7642 esac
7643 7643 fi
7644 7644 EXPR=$ac_cv_path_EXPR
7645 7645 if test -n "$EXPR"; then
7646 7646 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7647 7647 $as_echo "$EXPR" >&6; }
7648 7648 else
7649 7649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7650 7650 $as_echo "no" >&6; }
7651 7651 fi
7652 7652
7653 7653
7654 7654 test -n "$EXPR" && break
7655 7655 done
7656 7656
7657 7657 else
7658 7658 # The variable is set, but is it from the command line or the environment?
7659 7659
7660 7660 # Try to remove the string !EXPR! from our list.
7661 7661 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7662 7662 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7663 7663 # If it failed, the variable was not from the command line. Ignore it,
7664 7664 # but warn the user (except for BASH, which is always set by the calling BASH).
7665 7665 if test "xEXPR" != xBASH; then
7666 7666 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7667 7667 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7668 7668 fi
7669 7669 # Try to locate tool using the code snippet
7670 7670 for ac_prog in expr
7671 7671 do
7672 7672 # Extract the first word of "$ac_prog", so it can be a program name with args.
7673 7673 set dummy $ac_prog; ac_word=$2
7674 7674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7675 7675 $as_echo_n "checking for $ac_word... " >&6; }
7676 7676 if ${ac_cv_path_EXPR+:} false; then :
7677 7677 $as_echo_n "(cached) " >&6
7678 7678 else
7679 7679 case $EXPR in
7680 7680 [\\/]* | ?:[\\/]*)
7681 7681 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7682 7682 ;;
7683 7683 *)
7684 7684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7685 7685 for as_dir in $PATH
7686 7686 do
7687 7687 IFS=$as_save_IFS
7688 7688 test -z "$as_dir" && as_dir=.
7689 7689 for ac_exec_ext in '' $ac_executable_extensions; do
7690 7690 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7691 7691 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7692 7692 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7693 7693 break 2
7694 7694 fi
7695 7695 done
7696 7696 done
7697 7697 IFS=$as_save_IFS
7698 7698
7699 7699 ;;
7700 7700 esac
7701 7701 fi
7702 7702 EXPR=$ac_cv_path_EXPR
7703 7703 if test -n "$EXPR"; then
7704 7704 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7705 7705 $as_echo "$EXPR" >&6; }
7706 7706 else
7707 7707 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7708 7708 $as_echo "no" >&6; }
7709 7709 fi
7710 7710
7711 7711
7712 7712 test -n "$EXPR" && break
7713 7713 done
7714 7714
7715 7715 else
7716 7716 # If it succeeded, then it was overridden by the user. We will use it
7717 7717 # for the tool.
7718 7718
7719 7719 # First remove it from the list of overridden variables, so we can test
7720 7720 # for unknown variables in the end.
7721 7721 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7722 7722
7723 7723 # Check if we try to supply an empty value
7724 7724 if test "x$EXPR" = x; then
7725 7725 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7726 7726 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7727 7727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7728 7728 $as_echo_n "checking for EXPR... " >&6; }
7729 7729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7730 7730 $as_echo "disabled" >&6; }
7731 7731 else
7732 7732 # Check if the provided tool contains a complete path.
7733 7733 tool_specified="$EXPR"
7734 7734 tool_basename="${tool_specified##*/}"
7735 7735 if test "x$tool_basename" = "x$tool_specified"; then
7736 7736 # A command without a complete path is provided, search $PATH.
7737 7737 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7738 7738 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7739 7739 # Extract the first word of "$tool_basename", so it can be a program name with args.
7740 7740 set dummy $tool_basename; ac_word=$2
7741 7741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7742 7742 $as_echo_n "checking for $ac_word... " >&6; }
7743 7743 if ${ac_cv_path_EXPR+:} false; then :
7744 7744 $as_echo_n "(cached) " >&6
7745 7745 else
7746 7746 case $EXPR in
7747 7747 [\\/]* | ?:[\\/]*)
7748 7748 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7749 7749 ;;
7750 7750 *)
7751 7751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7752 7752 for as_dir in $PATH
7753 7753 do
7754 7754 IFS=$as_save_IFS
7755 7755 test -z "$as_dir" && as_dir=.
7756 7756 for ac_exec_ext in '' $ac_executable_extensions; do
7757 7757 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7758 7758 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7759 7759 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7760 7760 break 2
7761 7761 fi
7762 7762 done
7763 7763 done
7764 7764 IFS=$as_save_IFS
7765 7765
7766 7766 ;;
7767 7767 esac
7768 7768 fi
7769 7769 EXPR=$ac_cv_path_EXPR
7770 7770 if test -n "$EXPR"; then
7771 7771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7772 7772 $as_echo "$EXPR" >&6; }
7773 7773 else
7774 7774 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7775 7775 $as_echo "no" >&6; }
7776 7776 fi
7777 7777
7778 7778
7779 7779 if test "x$EXPR" = x; then
7780 7780 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7781 7781 fi
7782 7782 else
7783 7783 # Otherwise we believe it is a complete path. Use it as it is.
7784 7784 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7785 7785 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7786 7786 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7787 7787 $as_echo_n "checking for EXPR... " >&6; }
7788 7788 if test ! -x "$tool_specified"; then
7789 7789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7790 7790 $as_echo "not found" >&6; }
7791 7791 as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7792 7792 fi
7793 7793 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7794 7794 $as_echo "$tool_specified" >&6; }
7795 7795 fi
7796 7796 fi
7797 7797 fi
7798 7798
7799 7799 fi
7800 7800
7801 7801
7802 7802
7803 7803 if test "x$EXPR" = x; then
7804 7804 as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7805 7805 fi
7806 7806
7807 7807
7808 7808
7809 7809
7810 7810
7811 7811 # Publish this variable in the help.
7812 7812
7813 7813
7814 7814 if [ -z "${FILE+x}" ]; then
7815 7815 # The variable is not set by user, try to locate tool using the code snippet
7816 7816 for ac_prog in file
7817 7817 do
7818 7818 # Extract the first word of "$ac_prog", so it can be a program name with args.
7819 7819 set dummy $ac_prog; ac_word=$2
7820 7820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7821 7821 $as_echo_n "checking for $ac_word... " >&6; }
7822 7822 if ${ac_cv_path_FILE+:} false; then :
7823 7823 $as_echo_n "(cached) " >&6
7824 7824 else
7825 7825 case $FILE in
7826 7826 [\\/]* | ?:[\\/]*)
7827 7827 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7828 7828 ;;
7829 7829 *)
7830 7830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7831 7831 for as_dir in $PATH
7832 7832 do
7833 7833 IFS=$as_save_IFS
7834 7834 test -z "$as_dir" && as_dir=.
7835 7835 for ac_exec_ext in '' $ac_executable_extensions; do
7836 7836 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7837 7837 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7838 7838 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7839 7839 break 2
7840 7840 fi
7841 7841 done
7842 7842 done
7843 7843 IFS=$as_save_IFS
7844 7844
7845 7845 ;;
7846 7846 esac
7847 7847 fi
7848 7848 FILE=$ac_cv_path_FILE
7849 7849 if test -n "$FILE"; then
7850 7850 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7851 7851 $as_echo "$FILE" >&6; }
7852 7852 else
7853 7853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7854 7854 $as_echo "no" >&6; }
7855 7855 fi
7856 7856
7857 7857
7858 7858 test -n "$FILE" && break
7859 7859 done
7860 7860
7861 7861 else
7862 7862 # The variable is set, but is it from the command line or the environment?
7863 7863
7864 7864 # Try to remove the string !FILE! from our list.
7865 7865 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7866 7866 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7867 7867 # If it failed, the variable was not from the command line. Ignore it,
7868 7868 # but warn the user (except for BASH, which is always set by the calling BASH).
7869 7869 if test "xFILE" != xBASH; then
7870 7870 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7871 7871 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7872 7872 fi
7873 7873 # Try to locate tool using the code snippet
7874 7874 for ac_prog in file
7875 7875 do
7876 7876 # Extract the first word of "$ac_prog", so it can be a program name with args.
7877 7877 set dummy $ac_prog; ac_word=$2
7878 7878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7879 7879 $as_echo_n "checking for $ac_word... " >&6; }
7880 7880 if ${ac_cv_path_FILE+:} false; then :
7881 7881 $as_echo_n "(cached) " >&6
7882 7882 else
7883 7883 case $FILE in
7884 7884 [\\/]* | ?:[\\/]*)
7885 7885 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7886 7886 ;;
7887 7887 *)
7888 7888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7889 7889 for as_dir in $PATH
7890 7890 do
7891 7891 IFS=$as_save_IFS
7892 7892 test -z "$as_dir" && as_dir=.
7893 7893 for ac_exec_ext in '' $ac_executable_extensions; do
7894 7894 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7895 7895 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7896 7896 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7897 7897 break 2
7898 7898 fi
7899 7899 done
7900 7900 done
7901 7901 IFS=$as_save_IFS
7902 7902
7903 7903 ;;
7904 7904 esac
7905 7905 fi
7906 7906 FILE=$ac_cv_path_FILE
7907 7907 if test -n "$FILE"; then
7908 7908 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7909 7909 $as_echo "$FILE" >&6; }
7910 7910 else
7911 7911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7912 7912 $as_echo "no" >&6; }
7913 7913 fi
7914 7914
7915 7915
7916 7916 test -n "$FILE" && break
7917 7917 done
7918 7918
7919 7919 else
7920 7920 # If it succeeded, then it was overridden by the user. We will use it
7921 7921 # for the tool.
7922 7922
7923 7923 # First remove it from the list of overridden variables, so we can test
7924 7924 # for unknown variables in the end.
7925 7925 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7926 7926
7927 7927 # Check if we try to supply an empty value
7928 7928 if test "x$FILE" = x; then
7929 7929 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7930 7930 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7931 7931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7932 7932 $as_echo_n "checking for FILE... " >&6; }
7933 7933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7934 7934 $as_echo "disabled" >&6; }
7935 7935 else
7936 7936 # Check if the provided tool contains a complete path.
7937 7937 tool_specified="$FILE"
7938 7938 tool_basename="${tool_specified##*/}"
7939 7939 if test "x$tool_basename" = "x$tool_specified"; then
7940 7940 # A command without a complete path is provided, search $PATH.
7941 7941 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7942 7942 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7943 7943 # Extract the first word of "$tool_basename", so it can be a program name with args.
7944 7944 set dummy $tool_basename; ac_word=$2
7945 7945 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7946 7946 $as_echo_n "checking for $ac_word... " >&6; }
7947 7947 if ${ac_cv_path_FILE+:} false; then :
7948 7948 $as_echo_n "(cached) " >&6
7949 7949 else
7950 7950 case $FILE in
7951 7951 [\\/]* | ?:[\\/]*)
7952 7952 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7953 7953 ;;
7954 7954 *)
7955 7955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7956 7956 for as_dir in $PATH
7957 7957 do
7958 7958 IFS=$as_save_IFS
7959 7959 test -z "$as_dir" && as_dir=.
7960 7960 for ac_exec_ext in '' $ac_executable_extensions; do
7961 7961 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7962 7962 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7963 7963 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7964 7964 break 2
7965 7965 fi
7966 7966 done
7967 7967 done
7968 7968 IFS=$as_save_IFS
7969 7969
7970 7970 ;;
7971 7971 esac
7972 7972 fi
7973 7973 FILE=$ac_cv_path_FILE
7974 7974 if test -n "$FILE"; then
7975 7975 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7976 7976 $as_echo "$FILE" >&6; }
7977 7977 else
7978 7978 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7979 7979 $as_echo "no" >&6; }
7980 7980 fi
7981 7981
7982 7982
7983 7983 if test "x$FILE" = x; then
7984 7984 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7985 7985 fi
7986 7986 else
7987 7987 # Otherwise we believe it is a complete path. Use it as it is.
7988 7988 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7989 7989 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7990 7990 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7991 7991 $as_echo_n "checking for FILE... " >&6; }
7992 7992 if test ! -x "$tool_specified"; then
7993 7993 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7994 7994 $as_echo "not found" >&6; }
7995 7995 as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7996 7996 fi
7997 7997 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7998 7998 $as_echo "$tool_specified" >&6; }
7999 7999 fi
8000 8000 fi
8001 8001 fi
8002 8002
8003 8003 fi
8004 8004
8005 8005
8006 8006
8007 8007 if test "x$FILE" = x; then
8008 8008 as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
8009 8009 fi
8010 8010
8011 8011
8012 8012
8013 8013
8014 8014
8015 8015 # Publish this variable in the help.
8016 8016
8017 8017
8018 8018 if [ -z "${FIND+x}" ]; then
8019 8019 # The variable is not set by user, try to locate tool using the code snippet
8020 8020 for ac_prog in find
8021 8021 do
8022 8022 # Extract the first word of "$ac_prog", so it can be a program name with args.
8023 8023 set dummy $ac_prog; ac_word=$2
8024 8024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8025 8025 $as_echo_n "checking for $ac_word... " >&6; }
8026 8026 if ${ac_cv_path_FIND+:} false; then :
8027 8027 $as_echo_n "(cached) " >&6
8028 8028 else
8029 8029 case $FIND in
8030 8030 [\\/]* | ?:[\\/]*)
8031 8031 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8032 8032 ;;
8033 8033 *)
8034 8034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8035 8035 for as_dir in $PATH
8036 8036 do
8037 8037 IFS=$as_save_IFS
8038 8038 test -z "$as_dir" && as_dir=.
8039 8039 for ac_exec_ext in '' $ac_executable_extensions; do
8040 8040 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8041 8041 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8042 8042 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8043 8043 break 2
8044 8044 fi
8045 8045 done
8046 8046 done
8047 8047 IFS=$as_save_IFS
8048 8048
8049 8049 ;;
8050 8050 esac
8051 8051 fi
8052 8052 FIND=$ac_cv_path_FIND
8053 8053 if test -n "$FIND"; then
8054 8054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8055 8055 $as_echo "$FIND" >&6; }
8056 8056 else
8057 8057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8058 8058 $as_echo "no" >&6; }
8059 8059 fi
8060 8060
8061 8061
8062 8062 test -n "$FIND" && break
8063 8063 done
8064 8064
8065 8065 else
8066 8066 # The variable is set, but is it from the command line or the environment?
8067 8067
8068 8068 # Try to remove the string !FIND! from our list.
8069 8069 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
8070 8070 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8071 8071 # If it failed, the variable was not from the command line. Ignore it,
8072 8072 # but warn the user (except for BASH, which is always set by the calling BASH).
8073 8073 if test "xFIND" != xBASH; then
8074 8074 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
8075 8075 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
8076 8076 fi
8077 8077 # Try to locate tool using the code snippet
8078 8078 for ac_prog in find
8079 8079 do
8080 8080 # Extract the first word of "$ac_prog", so it can be a program name with args.
8081 8081 set dummy $ac_prog; ac_word=$2
8082 8082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8083 8083 $as_echo_n "checking for $ac_word... " >&6; }
8084 8084 if ${ac_cv_path_FIND+:} false; then :
8085 8085 $as_echo_n "(cached) " >&6
8086 8086 else
8087 8087 case $FIND in
8088 8088 [\\/]* | ?:[\\/]*)
8089 8089 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8090 8090 ;;
8091 8091 *)
8092 8092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8093 8093 for as_dir in $PATH
8094 8094 do
8095 8095 IFS=$as_save_IFS
8096 8096 test -z "$as_dir" && as_dir=.
8097 8097 for ac_exec_ext in '' $ac_executable_extensions; do
8098 8098 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8099 8099 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8100 8100 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8101 8101 break 2
8102 8102 fi
8103 8103 done
8104 8104 done
8105 8105 IFS=$as_save_IFS
8106 8106
8107 8107 ;;
8108 8108 esac
8109 8109 fi
8110 8110 FIND=$ac_cv_path_FIND
8111 8111 if test -n "$FIND"; then
8112 8112 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8113 8113 $as_echo "$FIND" >&6; }
8114 8114 else
8115 8115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8116 8116 $as_echo "no" >&6; }
8117 8117 fi
8118 8118
8119 8119
8120 8120 test -n "$FIND" && break
8121 8121 done
8122 8122
8123 8123 else
8124 8124 # If it succeeded, then it was overridden by the user. We will use it
8125 8125 # for the tool.
8126 8126
8127 8127 # First remove it from the list of overridden variables, so we can test
8128 8128 # for unknown variables in the end.
8129 8129 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8130 8130
8131 8131 # Check if we try to supply an empty value
8132 8132 if test "x$FIND" = x; then
8133 8133 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
8134 8134 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
8135 8135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8136 8136 $as_echo_n "checking for FIND... " >&6; }
8137 8137 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8138 8138 $as_echo "disabled" >&6; }
8139 8139 else
8140 8140 # Check if the provided tool contains a complete path.
8141 8141 tool_specified="$FIND"
8142 8142 tool_basename="${tool_specified##*/}"
8143 8143 if test "x$tool_basename" = "x$tool_specified"; then
8144 8144 # A command without a complete path is provided, search $PATH.
8145 8145 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
8146 8146 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
8147 8147 # Extract the first word of "$tool_basename", so it can be a program name with args.
8148 8148 set dummy $tool_basename; ac_word=$2
8149 8149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8150 8150 $as_echo_n "checking for $ac_word... " >&6; }
8151 8151 if ${ac_cv_path_FIND+:} false; then :
8152 8152 $as_echo_n "(cached) " >&6
8153 8153 else
8154 8154 case $FIND in
8155 8155 [\\/]* | ?:[\\/]*)
8156 8156 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8157 8157 ;;
8158 8158 *)
8159 8159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8160 8160 for as_dir in $PATH
8161 8161 do
8162 8162 IFS=$as_save_IFS
8163 8163 test -z "$as_dir" && as_dir=.
8164 8164 for ac_exec_ext in '' $ac_executable_extensions; do
8165 8165 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8166 8166 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8167 8167 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8168 8168 break 2
8169 8169 fi
8170 8170 done
8171 8171 done
8172 8172 IFS=$as_save_IFS
8173 8173
8174 8174 ;;
8175 8175 esac
8176 8176 fi
8177 8177 FIND=$ac_cv_path_FIND
8178 8178 if test -n "$FIND"; then
8179 8179 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8180 8180 $as_echo "$FIND" >&6; }
8181 8181 else
8182 8182 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8183 8183 $as_echo "no" >&6; }
8184 8184 fi
8185 8185
8186 8186
8187 8187 if test "x$FIND" = x; then
8188 8188 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8189 8189 fi
8190 8190 else
8191 8191 # Otherwise we believe it is a complete path. Use it as it is.
8192 8192 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
8193 8193 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
8194 8194 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8195 8195 $as_echo_n "checking for FIND... " >&6; }
8196 8196 if test ! -x "$tool_specified"; then
8197 8197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8198 8198 $as_echo "not found" >&6; }
8199 8199 as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
8200 8200 fi
8201 8201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8202 8202 $as_echo "$tool_specified" >&6; }
8203 8203 fi
8204 8204 fi
8205 8205 fi
8206 8206
8207 8207 fi
8208 8208
8209 8209
8210 8210
8211 8211 if test "x$FIND" = x; then
8212 8212 as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
8213 8213 fi
8214 8214
8215 8215
8216 8216
8217 8217
8218 8218
8219 8219 # Publish this variable in the help.
8220 8220
8221 8221
8222 8222 if [ -z "${HEAD+x}" ]; then
8223 8223 # The variable is not set by user, try to locate tool using the code snippet
8224 8224 for ac_prog in head
8225 8225 do
8226 8226 # Extract the first word of "$ac_prog", so it can be a program name with args.
8227 8227 set dummy $ac_prog; ac_word=$2
8228 8228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8229 8229 $as_echo_n "checking for $ac_word... " >&6; }
8230 8230 if ${ac_cv_path_HEAD+:} false; then :
8231 8231 $as_echo_n "(cached) " >&6
8232 8232 else
8233 8233 case $HEAD in
8234 8234 [\\/]* | ?:[\\/]*)
8235 8235 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8236 8236 ;;
8237 8237 *)
8238 8238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8239 8239 for as_dir in $PATH
8240 8240 do
8241 8241 IFS=$as_save_IFS
8242 8242 test -z "$as_dir" && as_dir=.
8243 8243 for ac_exec_ext in '' $ac_executable_extensions; do
8244 8244 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8245 8245 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8246 8246 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8247 8247 break 2
8248 8248 fi
8249 8249 done
8250 8250 done
8251 8251 IFS=$as_save_IFS
8252 8252
8253 8253 ;;
8254 8254 esac
8255 8255 fi
8256 8256 HEAD=$ac_cv_path_HEAD
8257 8257 if test -n "$HEAD"; then
8258 8258 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8259 8259 $as_echo "$HEAD" >&6; }
8260 8260 else
8261 8261 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8262 8262 $as_echo "no" >&6; }
8263 8263 fi
8264 8264
8265 8265
8266 8266 test -n "$HEAD" && break
8267 8267 done
8268 8268
8269 8269 else
8270 8270 # The variable is set, but is it from the command line or the environment?
8271 8271
8272 8272 # Try to remove the string !HEAD! from our list.
8273 8273 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
8274 8274 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8275 8275 # If it failed, the variable was not from the command line. Ignore it,
8276 8276 # but warn the user (except for BASH, which is always set by the calling BASH).
8277 8277 if test "xHEAD" != xBASH; then
8278 8278 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
8279 8279 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
8280 8280 fi
8281 8281 # Try to locate tool using the code snippet
8282 8282 for ac_prog in head
8283 8283 do
8284 8284 # Extract the first word of "$ac_prog", so it can be a program name with args.
8285 8285 set dummy $ac_prog; ac_word=$2
8286 8286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8287 8287 $as_echo_n "checking for $ac_word... " >&6; }
8288 8288 if ${ac_cv_path_HEAD+:} false; then :
8289 8289 $as_echo_n "(cached) " >&6
8290 8290 else
8291 8291 case $HEAD in
8292 8292 [\\/]* | ?:[\\/]*)
8293 8293 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8294 8294 ;;
8295 8295 *)
8296 8296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8297 8297 for as_dir in $PATH
8298 8298 do
8299 8299 IFS=$as_save_IFS
8300 8300 test -z "$as_dir" && as_dir=.
8301 8301 for ac_exec_ext in '' $ac_executable_extensions; do
8302 8302 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8303 8303 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8304 8304 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8305 8305 break 2
8306 8306 fi
8307 8307 done
8308 8308 done
8309 8309 IFS=$as_save_IFS
8310 8310
8311 8311 ;;
8312 8312 esac
8313 8313 fi
8314 8314 HEAD=$ac_cv_path_HEAD
8315 8315 if test -n "$HEAD"; then
8316 8316 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8317 8317 $as_echo "$HEAD" >&6; }
8318 8318 else
8319 8319 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8320 8320 $as_echo "no" >&6; }
8321 8321 fi
8322 8322
8323 8323
8324 8324 test -n "$HEAD" && break
8325 8325 done
8326 8326
8327 8327 else
8328 8328 # If it succeeded, then it was overridden by the user. We will use it
8329 8329 # for the tool.
8330 8330
8331 8331 # First remove it from the list of overridden variables, so we can test
8332 8332 # for unknown variables in the end.
8333 8333 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8334 8334
8335 8335 # Check if we try to supply an empty value
8336 8336 if test "x$HEAD" = x; then
8337 8337 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
8338 8338 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
8339 8339 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8340 8340 $as_echo_n "checking for HEAD... " >&6; }
8341 8341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8342 8342 $as_echo "disabled" >&6; }
8343 8343 else
8344 8344 # Check if the provided tool contains a complete path.
8345 8345 tool_specified="$HEAD"
8346 8346 tool_basename="${tool_specified##*/}"
8347 8347 if test "x$tool_basename" = "x$tool_specified"; then
8348 8348 # A command without a complete path is provided, search $PATH.
8349 8349 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
8350 8350 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
8351 8351 # Extract the first word of "$tool_basename", so it can be a program name with args.
8352 8352 set dummy $tool_basename; ac_word=$2
8353 8353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8354 8354 $as_echo_n "checking for $ac_word... " >&6; }
8355 8355 if ${ac_cv_path_HEAD+:} false; then :
8356 8356 $as_echo_n "(cached) " >&6
8357 8357 else
8358 8358 case $HEAD in
8359 8359 [\\/]* | ?:[\\/]*)
8360 8360 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8361 8361 ;;
8362 8362 *)
8363 8363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8364 8364 for as_dir in $PATH
8365 8365 do
8366 8366 IFS=$as_save_IFS
8367 8367 test -z "$as_dir" && as_dir=.
8368 8368 for ac_exec_ext in '' $ac_executable_extensions; do
8369 8369 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8370 8370 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8371 8371 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8372 8372 break 2
8373 8373 fi
8374 8374 done
8375 8375 done
8376 8376 IFS=$as_save_IFS
8377 8377
8378 8378 ;;
8379 8379 esac
8380 8380 fi
8381 8381 HEAD=$ac_cv_path_HEAD
8382 8382 if test -n "$HEAD"; then
8383 8383 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8384 8384 $as_echo "$HEAD" >&6; }
8385 8385 else
8386 8386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8387 8387 $as_echo "no" >&6; }
8388 8388 fi
8389 8389
8390 8390
8391 8391 if test "x$HEAD" = x; then
8392 8392 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8393 8393 fi
8394 8394 else
8395 8395 # Otherwise we believe it is a complete path. Use it as it is.
8396 8396 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8397 8397 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8398 8398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8399 8399 $as_echo_n "checking for HEAD... " >&6; }
8400 8400 if test ! -x "$tool_specified"; then
8401 8401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8402 8402 $as_echo "not found" >&6; }
8403 8403 as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8404 8404 fi
8405 8405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8406 8406 $as_echo "$tool_specified" >&6; }
8407 8407 fi
8408 8408 fi
8409 8409 fi
8410 8410
8411 8411 fi
8412 8412
8413 8413
8414 8414
8415 8415 if test "x$HEAD" = x; then
8416 8416 as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8417 8417 fi
8418 8418
8419 8419
8420 8420
8421 8421
8422 8422
8423 8423 # Publish this variable in the help.
8424 8424
8425 8425
8426 8426 if [ -z "${GUNZIP+x}" ]; then
8427 8427 # The variable is not set by user, try to locate tool using the code snippet
8428 8428 for ac_prog in gunzip
8429 8429 do
8430 8430 # Extract the first word of "$ac_prog", so it can be a program name with args.
8431 8431 set dummy $ac_prog; ac_word=$2
8432 8432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8433 8433 $as_echo_n "checking for $ac_word... " >&6; }
8434 8434 if ${ac_cv_path_GUNZIP+:} false; then :
8435 8435 $as_echo_n "(cached) " >&6
8436 8436 else
8437 8437 case $GUNZIP in
8438 8438 [\\/]* | ?:[\\/]*)
8439 8439 ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8440 8440 ;;
8441 8441 *)
8442 8442 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8443 8443 for as_dir in $PATH
8444 8444 do
8445 8445 IFS=$as_save_IFS
8446 8446 test -z "$as_dir" && as_dir=.
8447 8447 for ac_exec_ext in '' $ac_executable_extensions; do
8448 8448 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8449 8449 ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8450 8450 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8451 8451 break 2
8452 8452 fi
8453 8453 done
8454 8454 done
8455 8455 IFS=$as_save_IFS
8456 8456
8457 8457 ;;
8458 8458 esac
8459 8459 fi
8460 8460 GUNZIP=$ac_cv_path_GUNZIP
8461 8461 if test -n "$GUNZIP"; then
8462 8462 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8463 8463 $as_echo "$GUNZIP" >&6; }
8464 8464 else
8465 8465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8466 8466 $as_echo "no" >&6; }
8467 8467 fi
8468 8468
8469 8469
8470 8470 test -n "$GUNZIP" && break
8471 8471 done
8472 8472
8473 8473 else
8474 8474 # The variable is set, but is it from the command line or the environment?
8475 8475
8476 8476 # Try to remove the string !GUNZIP! from our list.
8477 8477 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GUNZIP!/}
8478 8478 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8479 8479 # If it failed, the variable was not from the command line. Ignore it,
8480 8480 # but warn the user (except for BASH, which is always set by the calling BASH).
8481 8481 if test "xGUNZIP" != xBASH; then
8482 8482 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&5
8483 8483 $as_echo "$as_me: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&2;}
8484 8484 fi
8485 8485 # Try to locate tool using the code snippet
8486 8486 for ac_prog in gunzip
8487 8487 do
8488 8488 # Extract the first word of "$ac_prog", so it can be a program name with args.
8489 8489 set dummy $ac_prog; ac_word=$2
8490 8490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8491 8491 $as_echo_n "checking for $ac_word... " >&6; }
8492 8492 if ${ac_cv_path_GUNZIP+:} false; then :
8493 8493 $as_echo_n "(cached) " >&6
8494 8494 else
8495 8495 case $GUNZIP in
8496 8496 [\\/]* | ?:[\\/]*)
8497 8497 ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8498 8498 ;;
8499 8499 *)
8500 8500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8501 8501 for as_dir in $PATH
8502 8502 do
8503 8503 IFS=$as_save_IFS
8504 8504 test -z "$as_dir" && as_dir=.
8505 8505 for ac_exec_ext in '' $ac_executable_extensions; do
8506 8506 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8507 8507 ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8508 8508 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8509 8509 break 2
8510 8510 fi
8511 8511 done
8512 8512 done
8513 8513 IFS=$as_save_IFS
8514 8514
8515 8515 ;;
8516 8516 esac
8517 8517 fi
8518 8518 GUNZIP=$ac_cv_path_GUNZIP
8519 8519 if test -n "$GUNZIP"; then
8520 8520 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8521 8521 $as_echo "$GUNZIP" >&6; }
8522 8522 else
8523 8523 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8524 8524 $as_echo "no" >&6; }
8525 8525 fi
8526 8526
8527 8527
8528 8528 test -n "$GUNZIP" && break
8529 8529 done
8530 8530
8531 8531 else
8532 8532 # If it succeeded, then it was overridden by the user. We will use it
8533 8533 # for the tool.
8534 8534
8535 8535 # First remove it from the list of overridden variables, so we can test
8536 8536 # for unknown variables in the end.
8537 8537 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8538 8538
8539 8539 # Check if we try to supply an empty value
8540 8540 if test "x$GUNZIP" = x; then
8541 8541 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GUNZIP= (no value)" >&5
8542 8542 $as_echo "$as_me: Setting user supplied tool GUNZIP= (no value)" >&6;}
8543 8543 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8544 8544 $as_echo_n "checking for GUNZIP... " >&6; }
8545 8545 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8546 8546 $as_echo "disabled" >&6; }
8547 8547 else
8548 8548 # Check if the provided tool contains a complete path.
8549 8549 tool_specified="$GUNZIP"
8550 8550 tool_basename="${tool_specified##*/}"
8551 8551 if test "x$tool_basename" = "x$tool_specified"; then
8552 8552 # A command without a complete path is provided, search $PATH.
8553 8553 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GUNZIP=$tool_basename" >&5
8554 8554 $as_echo "$as_me: Will search for user supplied tool GUNZIP=$tool_basename" >&6;}
8555 8555 # Extract the first word of "$tool_basename", so it can be a program name with args.
8556 8556 set dummy $tool_basename; ac_word=$2
8557 8557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8558 8558 $as_echo_n "checking for $ac_word... " >&6; }
8559 8559 if ${ac_cv_path_GUNZIP+:} false; then :
8560 8560 $as_echo_n "(cached) " >&6
8561 8561 else
8562 8562 case $GUNZIP in
8563 8563 [\\/]* | ?:[\\/]*)
8564 8564 ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8565 8565 ;;
8566 8566 *)
8567 8567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8568 8568 for as_dir in $PATH
8569 8569 do
8570 8570 IFS=$as_save_IFS
8571 8571 test -z "$as_dir" && as_dir=.
8572 8572 for ac_exec_ext in '' $ac_executable_extensions; do
8573 8573 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8574 8574 ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8575 8575 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8576 8576 break 2
8577 8577 fi
8578 8578 done
8579 8579 done
8580 8580 IFS=$as_save_IFS
8581 8581
8582 8582 ;;
8583 8583 esac
8584 8584 fi
8585 8585 GUNZIP=$ac_cv_path_GUNZIP
8586 8586 if test -n "$GUNZIP"; then
8587 8587 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8588 8588 $as_echo "$GUNZIP" >&6; }
8589 8589 else
8590 8590 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8591 8591 $as_echo "no" >&6; }
8592 8592 fi
8593 8593
8594 8594
8595 8595 if test "x$GUNZIP" = x; then
8596 8596 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8597 8597 fi
8598 8598 else
8599 8599 # Otherwise we believe it is a complete path. Use it as it is.
8600 8600 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GUNZIP=$tool_specified" >&5
8601 8601 $as_echo "$as_me: Will use user supplied tool GUNZIP=$tool_specified" >&6;}
8602 8602 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8603 8603 $as_echo_n "checking for GUNZIP... " >&6; }
8604 8604 if test ! -x "$tool_specified"; then
8605 8605 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8606 8606 $as_echo "not found" >&6; }
8607 8607 as_fn_error $? "User supplied tool GUNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8608 8608 fi
8609 8609 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8610 8610 $as_echo "$tool_specified" >&6; }
8611 8611 fi
8612 8612 fi
8613 8613 fi
8614 8614
8615 8615 fi
8616 8616
8617 8617
8618 8618
8619 8619 if test "x$GUNZIP" = x; then
8620 8620 as_fn_error $? "Could not find required tool for GUNZIP" "$LINENO" 5
8621 8621 fi
8622 8622
8623 8623
8624 8624
8625 8625
8626 8626
8627 8627 # Publish this variable in the help.
8628 8628
8629 8629
8630 8630 if [ -z "${GZIP+x}" ]; then
8631 8631 # The variable is not set by user, try to locate tool using the code snippet
8632 8632 for ac_prog in pigz gzip
8633 8633 do
8634 8634 # Extract the first word of "$ac_prog", so it can be a program name with args.
8635 8635 set dummy $ac_prog; ac_word=$2
8636 8636 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8637 8637 $as_echo_n "checking for $ac_word... " >&6; }
8638 8638 if ${ac_cv_path_GZIP+:} false; then :
8639 8639 $as_echo_n "(cached) " >&6
8640 8640 else
8641 8641 case $GZIP in
8642 8642 [\\/]* | ?:[\\/]*)
8643 8643 ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8644 8644 ;;
8645 8645 *)
8646 8646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8647 8647 for as_dir in $PATH
8648 8648 do
8649 8649 IFS=$as_save_IFS
8650 8650 test -z "$as_dir" && as_dir=.
8651 8651 for ac_exec_ext in '' $ac_executable_extensions; do
8652 8652 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8653 8653 ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8654 8654 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8655 8655 break 2
8656 8656 fi
8657 8657 done
8658 8658 done
8659 8659 IFS=$as_save_IFS
8660 8660
8661 8661 ;;
8662 8662 esac
8663 8663 fi
8664 8664 GZIP=$ac_cv_path_GZIP
8665 8665 if test -n "$GZIP"; then
8666 8666 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8667 8667 $as_echo "$GZIP" >&6; }
8668 8668 else
8669 8669 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8670 8670 $as_echo "no" >&6; }
8671 8671 fi
8672 8672
8673 8673
8674 8674 test -n "$GZIP" && break
8675 8675 done
8676 8676
8677 8677 else
8678 8678 # The variable is set, but is it from the command line or the environment?
8679 8679
8680 8680 # Try to remove the string !GZIP! from our list.
8681 8681 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GZIP!/}
8682 8682 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8683 8683 # If it failed, the variable was not from the command line. Ignore it,
8684 8684 # but warn the user (except for BASH, which is always set by the calling BASH).
8685 8685 if test "xGZIP" != xBASH; then
8686 8686 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&5
8687 8687 $as_echo "$as_me: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&2;}
8688 8688 fi
8689 8689 # Try to locate tool using the code snippet
8690 8690 for ac_prog in pigz gzip
8691 8691 do
8692 8692 # Extract the first word of "$ac_prog", so it can be a program name with args.
8693 8693 set dummy $ac_prog; ac_word=$2
8694 8694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8695 8695 $as_echo_n "checking for $ac_word... " >&6; }
8696 8696 if ${ac_cv_path_GZIP+:} false; then :
8697 8697 $as_echo_n "(cached) " >&6
8698 8698 else
8699 8699 case $GZIP in
8700 8700 [\\/]* | ?:[\\/]*)
8701 8701 ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8702 8702 ;;
8703 8703 *)
8704 8704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8705 8705 for as_dir in $PATH
8706 8706 do
8707 8707 IFS=$as_save_IFS
8708 8708 test -z "$as_dir" && as_dir=.
8709 8709 for ac_exec_ext in '' $ac_executable_extensions; do
8710 8710 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8711 8711 ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8712 8712 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8713 8713 break 2
8714 8714 fi
8715 8715 done
8716 8716 done
8717 8717 IFS=$as_save_IFS
8718 8718
8719 8719 ;;
8720 8720 esac
8721 8721 fi
8722 8722 GZIP=$ac_cv_path_GZIP
8723 8723 if test -n "$GZIP"; then
8724 8724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8725 8725 $as_echo "$GZIP" >&6; }
8726 8726 else
8727 8727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8728 8728 $as_echo "no" >&6; }
8729 8729 fi
8730 8730
8731 8731
8732 8732 test -n "$GZIP" && break
8733 8733 done
8734 8734
8735 8735 else
8736 8736 # If it succeeded, then it was overridden by the user. We will use it
8737 8737 # for the tool.
8738 8738
8739 8739 # First remove it from the list of overridden variables, so we can test
8740 8740 # for unknown variables in the end.
8741 8741 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8742 8742
8743 8743 # Check if we try to supply an empty value
8744 8744 if test "x$GZIP" = x; then
8745 8745 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GZIP= (no value)" >&5
8746 8746 $as_echo "$as_me: Setting user supplied tool GZIP= (no value)" >&6;}
8747 8747 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8748 8748 $as_echo_n "checking for GZIP... " >&6; }
8749 8749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8750 8750 $as_echo "disabled" >&6; }
8751 8751 else
8752 8752 # Check if the provided tool contains a complete path.
8753 8753 tool_specified="$GZIP"
8754 8754 tool_basename="${tool_specified##*/}"
8755 8755 if test "x$tool_basename" = "x$tool_specified"; then
8756 8756 # A command without a complete path is provided, search $PATH.
8757 8757 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GZIP=$tool_basename" >&5
8758 8758 $as_echo "$as_me: Will search for user supplied tool GZIP=$tool_basename" >&6;}
8759 8759 # Extract the first word of "$tool_basename", so it can be a program name with args.
8760 8760 set dummy $tool_basename; ac_word=$2
8761 8761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8762 8762 $as_echo_n "checking for $ac_word... " >&6; }
8763 8763 if ${ac_cv_path_GZIP+:} false; then :
8764 8764 $as_echo_n "(cached) " >&6
8765 8765 else
8766 8766 case $GZIP in
8767 8767 [\\/]* | ?:[\\/]*)
8768 8768 ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8769 8769 ;;
8770 8770 *)
8771 8771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8772 8772 for as_dir in $PATH
8773 8773 do
8774 8774 IFS=$as_save_IFS
8775 8775 test -z "$as_dir" && as_dir=.
8776 8776 for ac_exec_ext in '' $ac_executable_extensions; do
8777 8777 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8778 8778 ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8779 8779 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8780 8780 break 2
8781 8781 fi
8782 8782 done
8783 8783 done
8784 8784 IFS=$as_save_IFS
8785 8785
8786 8786 ;;
8787 8787 esac
8788 8788 fi
8789 8789 GZIP=$ac_cv_path_GZIP
8790 8790 if test -n "$GZIP"; then
8791 8791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8792 8792 $as_echo "$GZIP" >&6; }
8793 8793 else
8794 8794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8795 8795 $as_echo "no" >&6; }
8796 8796 fi
8797 8797
8798 8798
8799 8799 if test "x$GZIP" = x; then
8800 8800 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8801 8801 fi
8802 8802 else
8803 8803 # Otherwise we believe it is a complete path. Use it as it is.
8804 8804 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GZIP=$tool_specified" >&5
8805 8805 $as_echo "$as_me: Will use user supplied tool GZIP=$tool_specified" >&6;}
8806 8806 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8807 8807 $as_echo_n "checking for GZIP... " >&6; }
8808 8808 if test ! -x "$tool_specified"; then
8809 8809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8810 8810 $as_echo "not found" >&6; }
8811 8811 as_fn_error $? "User supplied tool GZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8812 8812 fi
8813 8813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8814 8814 $as_echo "$tool_specified" >&6; }
8815 8815 fi
8816 8816 fi
8817 8817 fi
8818 8818
8819 8819 fi
8820 8820
8821 8821
8822 8822
8823 8823 if test "x$GZIP" = x; then
8824 8824 as_fn_error $? "Could not find required tool for GZIP" "$LINENO" 5
8825 8825 fi
8826 8826
8827 8827
8828 8828
8829 8829
8830 8830
8831 8831 # Publish this variable in the help.
8832 8832
8833 8833
8834 8834 if [ -z "${LN+x}" ]; then
8835 8835 # The variable is not set by user, try to locate tool using the code snippet
8836 8836 for ac_prog in ln
8837 8837 do
8838 8838 # Extract the first word of "$ac_prog", so it can be a program name with args.
8839 8839 set dummy $ac_prog; ac_word=$2
8840 8840 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8841 8841 $as_echo_n "checking for $ac_word... " >&6; }
8842 8842 if ${ac_cv_path_LN+:} false; then :
8843 8843 $as_echo_n "(cached) " >&6
8844 8844 else
8845 8845 case $LN in
8846 8846 [\\/]* | ?:[\\/]*)
8847 8847 ac_cv_path_LN="$LN" # Let the user override the test with a path.
8848 8848 ;;
8849 8849 *)
8850 8850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 8851 for as_dir in $PATH
8852 8852 do
8853 8853 IFS=$as_save_IFS
8854 8854 test -z "$as_dir" && as_dir=.
8855 8855 for ac_exec_ext in '' $ac_executable_extensions; do
8856 8856 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857 8857 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8858 8858 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8859 8859 break 2
8860 8860 fi
8861 8861 done
8862 8862 done
8863 8863 IFS=$as_save_IFS
8864 8864
8865 8865 ;;
8866 8866 esac
8867 8867 fi
8868 8868 LN=$ac_cv_path_LN
8869 8869 if test -n "$LN"; then
8870 8870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8871 8871 $as_echo "$LN" >&6; }
8872 8872 else
8873 8873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8874 8874 $as_echo "no" >&6; }
8875 8875 fi
8876 8876
8877 8877
8878 8878 test -n "$LN" && break
8879 8879 done
8880 8880
8881 8881 else
8882 8882 # The variable is set, but is it from the command line or the environment?
8883 8883
8884 8884 # Try to remove the string !LN! from our list.
8885 8885 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8886 8886 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8887 8887 # If it failed, the variable was not from the command line. Ignore it,
8888 8888 # but warn the user (except for BASH, which is always set by the calling BASH).
8889 8889 if test "xLN" != xBASH; then
8890 8890 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8891 8891 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8892 8892 fi
8893 8893 # Try to locate tool using the code snippet
8894 8894 for ac_prog in ln
8895 8895 do
8896 8896 # Extract the first word of "$ac_prog", so it can be a program name with args.
8897 8897 set dummy $ac_prog; ac_word=$2
8898 8898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8899 8899 $as_echo_n "checking for $ac_word... " >&6; }
8900 8900 if ${ac_cv_path_LN+:} false; then :
8901 8901 $as_echo_n "(cached) " >&6
8902 8902 else
8903 8903 case $LN in
8904 8904 [\\/]* | ?:[\\/]*)
8905 8905 ac_cv_path_LN="$LN" # Let the user override the test with a path.
8906 8906 ;;
8907 8907 *)
8908 8908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8909 8909 for as_dir in $PATH
8910 8910 do
8911 8911 IFS=$as_save_IFS
8912 8912 test -z "$as_dir" && as_dir=.
8913 8913 for ac_exec_ext in '' $ac_executable_extensions; do
8914 8914 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8915 8915 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8916 8916 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8917 8917 break 2
8918 8918 fi
8919 8919 done
8920 8920 done
8921 8921 IFS=$as_save_IFS
8922 8922
8923 8923 ;;
8924 8924 esac
8925 8925 fi
8926 8926 LN=$ac_cv_path_LN
8927 8927 if test -n "$LN"; then
8928 8928 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8929 8929 $as_echo "$LN" >&6; }
8930 8930 else
8931 8931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8932 8932 $as_echo "no" >&6; }
8933 8933 fi
8934 8934
8935 8935
8936 8936 test -n "$LN" && break
8937 8937 done
8938 8938
8939 8939 else
8940 8940 # If it succeeded, then it was overridden by the user. We will use it
8941 8941 # for the tool.
8942 8942
8943 8943 # First remove it from the list of overridden variables, so we can test
8944 8944 # for unknown variables in the end.
8945 8945 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8946 8946
8947 8947 # Check if we try to supply an empty value
8948 8948 if test "x$LN" = x; then
8949 8949 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8950 8950 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8951 8951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8952 8952 $as_echo_n "checking for LN... " >&6; }
8953 8953 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8954 8954 $as_echo "disabled" >&6; }
8955 8955 else
8956 8956 # Check if the provided tool contains a complete path.
8957 8957 tool_specified="$LN"
8958 8958 tool_basename="${tool_specified##*/}"
8959 8959 if test "x$tool_basename" = "x$tool_specified"; then
8960 8960 # A command without a complete path is provided, search $PATH.
8961 8961 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8962 8962 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8963 8963 # Extract the first word of "$tool_basename", so it can be a program name with args.
8964 8964 set dummy $tool_basename; ac_word=$2
8965 8965 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8966 8966 $as_echo_n "checking for $ac_word... " >&6; }
8967 8967 if ${ac_cv_path_LN+:} false; then :
8968 8968 $as_echo_n "(cached) " >&6
8969 8969 else
8970 8970 case $LN in
8971 8971 [\\/]* | ?:[\\/]*)
8972 8972 ac_cv_path_LN="$LN" # Let the user override the test with a path.
8973 8973 ;;
8974 8974 *)
8975 8975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8976 8976 for as_dir in $PATH
8977 8977 do
8978 8978 IFS=$as_save_IFS
8979 8979 test -z "$as_dir" && as_dir=.
8980 8980 for ac_exec_ext in '' $ac_executable_extensions; do
8981 8981 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8982 8982 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8983 8983 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8984 8984 break 2
8985 8985 fi
8986 8986 done
8987 8987 done
8988 8988 IFS=$as_save_IFS
8989 8989
8990 8990 ;;
8991 8991 esac
8992 8992 fi
8993 8993 LN=$ac_cv_path_LN
8994 8994 if test -n "$LN"; then
8995 8995 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8996 8996 $as_echo "$LN" >&6; }
8997 8997 else
8998 8998 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8999 8999 $as_echo "no" >&6; }
9000 9000 fi
9001 9001
9002 9002
9003 9003 if test "x$LN" = x; then
9004 9004 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9005 9005 fi
9006 9006 else
9007 9007 # Otherwise we believe it is a complete path. Use it as it is.
9008 9008 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
9009 9009 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
9010 9010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
9011 9011 $as_echo_n "checking for LN... " >&6; }
9012 9012 if test ! -x "$tool_specified"; then
9013 9013 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9014 9014 $as_echo "not found" >&6; }
9015 9015 as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
9016 9016 fi
9017 9017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9018 9018 $as_echo "$tool_specified" >&6; }
9019 9019 fi
9020 9020 fi
9021 9021 fi
9022 9022
9023 9023 fi
9024 9024
9025 9025
9026 9026
9027 9027 if test "x$LN" = x; then
9028 9028 as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
9029 9029 fi
9030 9030
9031 9031
9032 9032
9033 9033
9034 9034
9035 9035 # Publish this variable in the help.
9036 9036
9037 9037
9038 9038 if [ -z "${LS+x}" ]; then
9039 9039 # The variable is not set by user, try to locate tool using the code snippet
9040 9040 for ac_prog in ls
9041 9041 do
9042 9042 # Extract the first word of "$ac_prog", so it can be a program name with args.
9043 9043 set dummy $ac_prog; ac_word=$2
9044 9044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9045 9045 $as_echo_n "checking for $ac_word... " >&6; }
9046 9046 if ${ac_cv_path_LS+:} false; then :
9047 9047 $as_echo_n "(cached) " >&6
9048 9048 else
9049 9049 case $LS in
9050 9050 [\\/]* | ?:[\\/]*)
9051 9051 ac_cv_path_LS="$LS" # Let the user override the test with a path.
9052 9052 ;;
9053 9053 *)
9054 9054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 9055 for as_dir in $PATH
9056 9056 do
9057 9057 IFS=$as_save_IFS
9058 9058 test -z "$as_dir" && as_dir=.
9059 9059 for ac_exec_ext in '' $ac_executable_extensions; do
9060 9060 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061 9061 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9062 9062 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9063 9063 break 2
9064 9064 fi
9065 9065 done
9066 9066 done
9067 9067 IFS=$as_save_IFS
9068 9068
9069 9069 ;;
9070 9070 esac
9071 9071 fi
9072 9072 LS=$ac_cv_path_LS
9073 9073 if test -n "$LS"; then
9074 9074 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9075 9075 $as_echo "$LS" >&6; }
9076 9076 else
9077 9077 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9078 9078 $as_echo "no" >&6; }
9079 9079 fi
9080 9080
9081 9081
9082 9082 test -n "$LS" && break
9083 9083 done
9084 9084
9085 9085 else
9086 9086 # The variable is set, but is it from the command line or the environment?
9087 9087
9088 9088 # Try to remove the string !LS! from our list.
9089 9089 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
9090 9090 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9091 9091 # If it failed, the variable was not from the command line. Ignore it,
9092 9092 # but warn the user (except for BASH, which is always set by the calling BASH).
9093 9093 if test "xLS" != xBASH; then
9094 9094 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
9095 9095 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
9096 9096 fi
9097 9097 # Try to locate tool using the code snippet
9098 9098 for ac_prog in ls
9099 9099 do
9100 9100 # Extract the first word of "$ac_prog", so it can be a program name with args.
9101 9101 set dummy $ac_prog; ac_word=$2
9102 9102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9103 9103 $as_echo_n "checking for $ac_word... " >&6; }
9104 9104 if ${ac_cv_path_LS+:} false; then :
9105 9105 $as_echo_n "(cached) " >&6
9106 9106 else
9107 9107 case $LS in
9108 9108 [\\/]* | ?:[\\/]*)
9109 9109 ac_cv_path_LS="$LS" # Let the user override the test with a path.
9110 9110 ;;
9111 9111 *)
9112 9112 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9113 9113 for as_dir in $PATH
9114 9114 do
9115 9115 IFS=$as_save_IFS
9116 9116 test -z "$as_dir" && as_dir=.
9117 9117 for ac_exec_ext in '' $ac_executable_extensions; do
9118 9118 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9119 9119 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9120 9120 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9121 9121 break 2
9122 9122 fi
9123 9123 done
9124 9124 done
9125 9125 IFS=$as_save_IFS
9126 9126
9127 9127 ;;
9128 9128 esac
9129 9129 fi
9130 9130 LS=$ac_cv_path_LS
9131 9131 if test -n "$LS"; then
9132 9132 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9133 9133 $as_echo "$LS" >&6; }
9134 9134 else
9135 9135 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9136 9136 $as_echo "no" >&6; }
9137 9137 fi
9138 9138
9139 9139
9140 9140 test -n "$LS" && break
9141 9141 done
9142 9142
9143 9143 else
9144 9144 # If it succeeded, then it was overridden by the user. We will use it
9145 9145 # for the tool.
9146 9146
9147 9147 # First remove it from the list of overridden variables, so we can test
9148 9148 # for unknown variables in the end.
9149 9149 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9150 9150
9151 9151 # Check if we try to supply an empty value
9152 9152 if test "x$LS" = x; then
9153 9153 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
9154 9154 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
9155 9155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9156 9156 $as_echo_n "checking for LS... " >&6; }
9157 9157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9158 9158 $as_echo "disabled" >&6; }
9159 9159 else
9160 9160 # Check if the provided tool contains a complete path.
9161 9161 tool_specified="$LS"
9162 9162 tool_basename="${tool_specified##*/}"
9163 9163 if test "x$tool_basename" = "x$tool_specified"; then
9164 9164 # A command without a complete path is provided, search $PATH.
9165 9165 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
9166 9166 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
9167 9167 # Extract the first word of "$tool_basename", so it can be a program name with args.
9168 9168 set dummy $tool_basename; ac_word=$2
9169 9169 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9170 9170 $as_echo_n "checking for $ac_word... " >&6; }
9171 9171 if ${ac_cv_path_LS+:} false; then :
9172 9172 $as_echo_n "(cached) " >&6
9173 9173 else
9174 9174 case $LS in
9175 9175 [\\/]* | ?:[\\/]*)
9176 9176 ac_cv_path_LS="$LS" # Let the user override the test with a path.
9177 9177 ;;
9178 9178 *)
9179 9179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9180 9180 for as_dir in $PATH
9181 9181 do
9182 9182 IFS=$as_save_IFS
9183 9183 test -z "$as_dir" && as_dir=.
9184 9184 for ac_exec_ext in '' $ac_executable_extensions; do
9185 9185 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9186 9186 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9187 9187 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9188 9188 break 2
9189 9189 fi
9190 9190 done
9191 9191 done
9192 9192 IFS=$as_save_IFS
9193 9193
9194 9194 ;;
9195 9195 esac
9196 9196 fi
9197 9197 LS=$ac_cv_path_LS
9198 9198 if test -n "$LS"; then
9199 9199 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9200 9200 $as_echo "$LS" >&6; }
9201 9201 else
9202 9202 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9203 9203 $as_echo "no" >&6; }
9204 9204 fi
9205 9205
9206 9206
9207 9207 if test "x$LS" = x; then
9208 9208 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9209 9209 fi
9210 9210 else
9211 9211 # Otherwise we believe it is a complete path. Use it as it is.
9212 9212 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
9213 9213 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
9214 9214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9215 9215 $as_echo_n "checking for LS... " >&6; }
9216 9216 if test ! -x "$tool_specified"; then
9217 9217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9218 9218 $as_echo "not found" >&6; }
9219 9219 as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
9220 9220 fi
9221 9221 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9222 9222 $as_echo "$tool_specified" >&6; }
9223 9223 fi
9224 9224 fi
9225 9225 fi
9226 9226
9227 9227 fi
9228 9228
9229 9229
9230 9230
9231 9231 if test "x$LS" = x; then
9232 9232 as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
9233 9233 fi
9234 9234
9235 9235
9236 9236
9237 9237
9238 9238
9239 9239 # Publish this variable in the help.
9240 9240
9241 9241
9242 9242 if [ -z "${MKDIR+x}" ]; then
9243 9243 # The variable is not set by user, try to locate tool using the code snippet
9244 9244 for ac_prog in mkdir
9245 9245 do
9246 9246 # Extract the first word of "$ac_prog", so it can be a program name with args.
9247 9247 set dummy $ac_prog; ac_word=$2
9248 9248 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9249 9249 $as_echo_n "checking for $ac_word... " >&6; }
9250 9250 if ${ac_cv_path_MKDIR+:} false; then :
9251 9251 $as_echo_n "(cached) " >&6
9252 9252 else
9253 9253 case $MKDIR in
9254 9254 [\\/]* | ?:[\\/]*)
9255 9255 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9256 9256 ;;
9257 9257 *)
9258 9258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9259 9259 for as_dir in $PATH
9260 9260 do
9261 9261 IFS=$as_save_IFS
9262 9262 test -z "$as_dir" && as_dir=.
9263 9263 for ac_exec_ext in '' $ac_executable_extensions; do
9264 9264 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9265 9265 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9266 9266 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9267 9267 break 2
9268 9268 fi
9269 9269 done
9270 9270 done
9271 9271 IFS=$as_save_IFS
9272 9272
9273 9273 ;;
9274 9274 esac
9275 9275 fi
9276 9276 MKDIR=$ac_cv_path_MKDIR
9277 9277 if test -n "$MKDIR"; then
9278 9278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9279 9279 $as_echo "$MKDIR" >&6; }
9280 9280 else
9281 9281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9282 9282 $as_echo "no" >&6; }
9283 9283 fi
9284 9284
9285 9285
9286 9286 test -n "$MKDIR" && break
9287 9287 done
9288 9288
9289 9289 else
9290 9290 # The variable is set, but is it from the command line or the environment?
9291 9291
9292 9292 # Try to remove the string !MKDIR! from our list.
9293 9293 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
9294 9294 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9295 9295 # If it failed, the variable was not from the command line. Ignore it,
9296 9296 # but warn the user (except for BASH, which is always set by the calling BASH).
9297 9297 if test "xMKDIR" != xBASH; then
9298 9298 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
9299 9299 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
9300 9300 fi
9301 9301 # Try to locate tool using the code snippet
9302 9302 for ac_prog in mkdir
9303 9303 do
9304 9304 # Extract the first word of "$ac_prog", so it can be a program name with args.
9305 9305 set dummy $ac_prog; ac_word=$2
9306 9306 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9307 9307 $as_echo_n "checking for $ac_word... " >&6; }
9308 9308 if ${ac_cv_path_MKDIR+:} false; then :
9309 9309 $as_echo_n "(cached) " >&6
9310 9310 else
9311 9311 case $MKDIR in
9312 9312 [\\/]* | ?:[\\/]*)
9313 9313 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9314 9314 ;;
9315 9315 *)
9316 9316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9317 9317 for as_dir in $PATH
9318 9318 do
9319 9319 IFS=$as_save_IFS
9320 9320 test -z "$as_dir" && as_dir=.
9321 9321 for ac_exec_ext in '' $ac_executable_extensions; do
9322 9322 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9323 9323 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9324 9324 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9325 9325 break 2
9326 9326 fi
9327 9327 done
9328 9328 done
9329 9329 IFS=$as_save_IFS
9330 9330
9331 9331 ;;
9332 9332 esac
9333 9333 fi
9334 9334 MKDIR=$ac_cv_path_MKDIR
9335 9335 if test -n "$MKDIR"; then
9336 9336 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9337 9337 $as_echo "$MKDIR" >&6; }
9338 9338 else
9339 9339 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9340 9340 $as_echo "no" >&6; }
9341 9341 fi
9342 9342
9343 9343
9344 9344 test -n "$MKDIR" && break
9345 9345 done
9346 9346
9347 9347 else
9348 9348 # If it succeeded, then it was overridden by the user. We will use it
9349 9349 # for the tool.
9350 9350
9351 9351 # First remove it from the list of overridden variables, so we can test
9352 9352 # for unknown variables in the end.
9353 9353 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9354 9354
9355 9355 # Check if we try to supply an empty value
9356 9356 if test "x$MKDIR" = x; then
9357 9357 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
9358 9358 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
9359 9359 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9360 9360 $as_echo_n "checking for MKDIR... " >&6; }
9361 9361 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9362 9362 $as_echo "disabled" >&6; }
9363 9363 else
9364 9364 # Check if the provided tool contains a complete path.
9365 9365 tool_specified="$MKDIR"
9366 9366 tool_basename="${tool_specified##*/}"
9367 9367 if test "x$tool_basename" = "x$tool_specified"; then
9368 9368 # A command without a complete path is provided, search $PATH.
9369 9369 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
9370 9370 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
9371 9371 # Extract the first word of "$tool_basename", so it can be a program name with args.
9372 9372 set dummy $tool_basename; ac_word=$2
9373 9373 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9374 9374 $as_echo_n "checking for $ac_word... " >&6; }
9375 9375 if ${ac_cv_path_MKDIR+:} false; then :
9376 9376 $as_echo_n "(cached) " >&6
9377 9377 else
9378 9378 case $MKDIR in
9379 9379 [\\/]* | ?:[\\/]*)
9380 9380 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9381 9381 ;;
9382 9382 *)
9383 9383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9384 9384 for as_dir in $PATH
9385 9385 do
9386 9386 IFS=$as_save_IFS
9387 9387 test -z "$as_dir" && as_dir=.
9388 9388 for ac_exec_ext in '' $ac_executable_extensions; do
9389 9389 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9390 9390 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9391 9391 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9392 9392 break 2
9393 9393 fi
9394 9394 done
9395 9395 done
9396 9396 IFS=$as_save_IFS
9397 9397
9398 9398 ;;
9399 9399 esac
9400 9400 fi
9401 9401 MKDIR=$ac_cv_path_MKDIR
9402 9402 if test -n "$MKDIR"; then
9403 9403 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9404 9404 $as_echo "$MKDIR" >&6; }
9405 9405 else
9406 9406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9407 9407 $as_echo "no" >&6; }
9408 9408 fi
9409 9409
9410 9410
9411 9411 if test "x$MKDIR" = x; then
9412 9412 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9413 9413 fi
9414 9414 else
9415 9415 # Otherwise we believe it is a complete path. Use it as it is.
9416 9416 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
9417 9417 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
9418 9418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9419 9419 $as_echo_n "checking for MKDIR... " >&6; }
9420 9420 if test ! -x "$tool_specified"; then
9421 9421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9422 9422 $as_echo "not found" >&6; }
9423 9423 as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
9424 9424 fi
9425 9425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9426 9426 $as_echo "$tool_specified" >&6; }
9427 9427 fi
9428 9428 fi
9429 9429 fi
9430 9430
9431 9431 fi
9432 9432
9433 9433
9434 9434
9435 9435 if test "x$MKDIR" = x; then
9436 9436 as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
9437 9437 fi
9438 9438
9439 9439
9440 9440
9441 9441
9442 9442
9443 9443 # Publish this variable in the help.
9444 9444
9445 9445
9446 9446 if [ -z "${MKTEMP+x}" ]; then
9447 9447 # The variable is not set by user, try to locate tool using the code snippet
9448 9448 for ac_prog in mktemp
9449 9449 do
9450 9450 # Extract the first word of "$ac_prog", so it can be a program name with args.
9451 9451 set dummy $ac_prog; ac_word=$2
9452 9452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9453 9453 $as_echo_n "checking for $ac_word... " >&6; }
9454 9454 if ${ac_cv_path_MKTEMP+:} false; then :
9455 9455 $as_echo_n "(cached) " >&6
9456 9456 else
9457 9457 case $MKTEMP in
9458 9458 [\\/]* | ?:[\\/]*)
9459 9459 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9460 9460 ;;
9461 9461 *)
9462 9462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9463 9463 for as_dir in $PATH
9464 9464 do
9465 9465 IFS=$as_save_IFS
9466 9466 test -z "$as_dir" && as_dir=.
9467 9467 for ac_exec_ext in '' $ac_executable_extensions; do
9468 9468 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9469 9469 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9470 9470 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9471 9471 break 2
9472 9472 fi
9473 9473 done
9474 9474 done
9475 9475 IFS=$as_save_IFS
9476 9476
9477 9477 ;;
9478 9478 esac
9479 9479 fi
9480 9480 MKTEMP=$ac_cv_path_MKTEMP
9481 9481 if test -n "$MKTEMP"; then
9482 9482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9483 9483 $as_echo "$MKTEMP" >&6; }
9484 9484 else
9485 9485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9486 9486 $as_echo "no" >&6; }
9487 9487 fi
9488 9488
9489 9489
9490 9490 test -n "$MKTEMP" && break
9491 9491 done
9492 9492
9493 9493 else
9494 9494 # The variable is set, but is it from the command line or the environment?
9495 9495
9496 9496 # Try to remove the string !MKTEMP! from our list.
9497 9497 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
9498 9498 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9499 9499 # If it failed, the variable was not from the command line. Ignore it,
9500 9500 # but warn the user (except for BASH, which is always set by the calling BASH).
9501 9501 if test "xMKTEMP" != xBASH; then
9502 9502 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
9503 9503 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
9504 9504 fi
9505 9505 # Try to locate tool using the code snippet
9506 9506 for ac_prog in mktemp
9507 9507 do
9508 9508 # Extract the first word of "$ac_prog", so it can be a program name with args.
9509 9509 set dummy $ac_prog; ac_word=$2
9510 9510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9511 9511 $as_echo_n "checking for $ac_word... " >&6; }
9512 9512 if ${ac_cv_path_MKTEMP+:} false; then :
9513 9513 $as_echo_n "(cached) " >&6
9514 9514 else
9515 9515 case $MKTEMP in
9516 9516 [\\/]* | ?:[\\/]*)
9517 9517 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9518 9518 ;;
9519 9519 *)
9520 9520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9521 9521 for as_dir in $PATH
9522 9522 do
9523 9523 IFS=$as_save_IFS
9524 9524 test -z "$as_dir" && as_dir=.
9525 9525 for ac_exec_ext in '' $ac_executable_extensions; do
9526 9526 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9527 9527 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9528 9528 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9529 9529 break 2
9530 9530 fi
9531 9531 done
9532 9532 done
9533 9533 IFS=$as_save_IFS
9534 9534
9535 9535 ;;
9536 9536 esac
9537 9537 fi
9538 9538 MKTEMP=$ac_cv_path_MKTEMP
9539 9539 if test -n "$MKTEMP"; then
9540 9540 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9541 9541 $as_echo "$MKTEMP" >&6; }
9542 9542 else
9543 9543 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9544 9544 $as_echo "no" >&6; }
9545 9545 fi
9546 9546
9547 9547
9548 9548 test -n "$MKTEMP" && break
9549 9549 done
9550 9550
9551 9551 else
9552 9552 # If it succeeded, then it was overridden by the user. We will use it
9553 9553 # for the tool.
9554 9554
9555 9555 # First remove it from the list of overridden variables, so we can test
9556 9556 # for unknown variables in the end.
9557 9557 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9558 9558
9559 9559 # Check if we try to supply an empty value
9560 9560 if test "x$MKTEMP" = x; then
9561 9561 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
9562 9562 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
9563 9563 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9564 9564 $as_echo_n "checking for MKTEMP... " >&6; }
9565 9565 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9566 9566 $as_echo "disabled" >&6; }
9567 9567 else
9568 9568 # Check if the provided tool contains a complete path.
9569 9569 tool_specified="$MKTEMP"
9570 9570 tool_basename="${tool_specified##*/}"
9571 9571 if test "x$tool_basename" = "x$tool_specified"; then
9572 9572 # A command without a complete path is provided, search $PATH.
9573 9573 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
9574 9574 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
9575 9575 # Extract the first word of "$tool_basename", so it can be a program name with args.
9576 9576 set dummy $tool_basename; ac_word=$2
9577 9577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9578 9578 $as_echo_n "checking for $ac_word... " >&6; }
9579 9579 if ${ac_cv_path_MKTEMP+:} false; then :
9580 9580 $as_echo_n "(cached) " >&6
9581 9581 else
9582 9582 case $MKTEMP in
9583 9583 [\\/]* | ?:[\\/]*)
9584 9584 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9585 9585 ;;
9586 9586 *)
9587 9587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9588 9588 for as_dir in $PATH
9589 9589 do
9590 9590 IFS=$as_save_IFS
9591 9591 test -z "$as_dir" && as_dir=.
9592 9592 for ac_exec_ext in '' $ac_executable_extensions; do
9593 9593 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9594 9594 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9595 9595 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9596 9596 break 2
9597 9597 fi
9598 9598 done
9599 9599 done
9600 9600 IFS=$as_save_IFS
9601 9601
9602 9602 ;;
9603 9603 esac
9604 9604 fi
9605 9605 MKTEMP=$ac_cv_path_MKTEMP
9606 9606 if test -n "$MKTEMP"; then
9607 9607 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9608 9608 $as_echo "$MKTEMP" >&6; }
9609 9609 else
9610 9610 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9611 9611 $as_echo "no" >&6; }
9612 9612 fi
9613 9613
9614 9614
9615 9615 if test "x$MKTEMP" = x; then
9616 9616 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9617 9617 fi
9618 9618 else
9619 9619 # Otherwise we believe it is a complete path. Use it as it is.
9620 9620 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
9621 9621 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
9622 9622 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9623 9623 $as_echo_n "checking for MKTEMP... " >&6; }
9624 9624 if test ! -x "$tool_specified"; then
9625 9625 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9626 9626 $as_echo "not found" >&6; }
9627 9627 as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
9628 9628 fi
9629 9629 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9630 9630 $as_echo "$tool_specified" >&6; }
9631 9631 fi
9632 9632 fi
9633 9633 fi
9634 9634
9635 9635 fi
9636 9636
9637 9637
9638 9638
9639 9639 if test "x$MKTEMP" = x; then
9640 9640 as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
9641 9641 fi
9642 9642
9643 9643
9644 9644
9645 9645
9646 9646
9647 9647 # Publish this variable in the help.
9648 9648
9649 9649
9650 9650 if [ -z "${MV+x}" ]; then
9651 9651 # The variable is not set by user, try to locate tool using the code snippet
9652 9652 for ac_prog in mv
9653 9653 do
9654 9654 # Extract the first word of "$ac_prog", so it can be a program name with args.
9655 9655 set dummy $ac_prog; ac_word=$2
9656 9656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9657 9657 $as_echo_n "checking for $ac_word... " >&6; }
9658 9658 if ${ac_cv_path_MV+:} false; then :
9659 9659 $as_echo_n "(cached) " >&6
9660 9660 else
9661 9661 case $MV in
9662 9662 [\\/]* | ?:[\\/]*)
9663 9663 ac_cv_path_MV="$MV" # Let the user override the test with a path.
9664 9664 ;;
9665 9665 *)
9666 9666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9667 9667 for as_dir in $PATH
9668 9668 do
9669 9669 IFS=$as_save_IFS
9670 9670 test -z "$as_dir" && as_dir=.
9671 9671 for ac_exec_ext in '' $ac_executable_extensions; do
9672 9672 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9673 9673 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9674 9674 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9675 9675 break 2
9676 9676 fi
9677 9677 done
9678 9678 done
9679 9679 IFS=$as_save_IFS
9680 9680
9681 9681 ;;
9682 9682 esac
9683 9683 fi
9684 9684 MV=$ac_cv_path_MV
9685 9685 if test -n "$MV"; then
9686 9686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9687 9687 $as_echo "$MV" >&6; }
9688 9688 else
9689 9689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9690 9690 $as_echo "no" >&6; }
9691 9691 fi
9692 9692
9693 9693
9694 9694 test -n "$MV" && break
9695 9695 done
9696 9696
9697 9697 else
9698 9698 # The variable is set, but is it from the command line or the environment?
9699 9699
9700 9700 # Try to remove the string !MV! from our list.
9701 9701 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
9702 9702 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9703 9703 # If it failed, the variable was not from the command line. Ignore it,
9704 9704 # but warn the user (except for BASH, which is always set by the calling BASH).
9705 9705 if test "xMV" != xBASH; then
9706 9706 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
9707 9707 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
9708 9708 fi
9709 9709 # Try to locate tool using the code snippet
9710 9710 for ac_prog in mv
9711 9711 do
9712 9712 # Extract the first word of "$ac_prog", so it can be a program name with args.
9713 9713 set dummy $ac_prog; ac_word=$2
9714 9714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9715 9715 $as_echo_n "checking for $ac_word... " >&6; }
9716 9716 if ${ac_cv_path_MV+:} false; then :
9717 9717 $as_echo_n "(cached) " >&6
9718 9718 else
9719 9719 case $MV in
9720 9720 [\\/]* | ?:[\\/]*)
9721 9721 ac_cv_path_MV="$MV" # Let the user override the test with a path.
9722 9722 ;;
9723 9723 *)
9724 9724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9725 9725 for as_dir in $PATH
9726 9726 do
9727 9727 IFS=$as_save_IFS
9728 9728 test -z "$as_dir" && as_dir=.
9729 9729 for ac_exec_ext in '' $ac_executable_extensions; do
9730 9730 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9731 9731 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9732 9732 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9733 9733 break 2
9734 9734 fi
9735 9735 done
9736 9736 done
9737 9737 IFS=$as_save_IFS
9738 9738
9739 9739 ;;
9740 9740 esac
9741 9741 fi
9742 9742 MV=$ac_cv_path_MV
9743 9743 if test -n "$MV"; then
9744 9744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9745 9745 $as_echo "$MV" >&6; }
9746 9746 else
9747 9747 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9748 9748 $as_echo "no" >&6; }
9749 9749 fi
9750 9750
9751 9751
9752 9752 test -n "$MV" && break
9753 9753 done
9754 9754
9755 9755 else
9756 9756 # If it succeeded, then it was overridden by the user. We will use it
9757 9757 # for the tool.
9758 9758
9759 9759 # First remove it from the list of overridden variables, so we can test
9760 9760 # for unknown variables in the end.
9761 9761 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9762 9762
9763 9763 # Check if we try to supply an empty value
9764 9764 if test "x$MV" = x; then
9765 9765 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
9766 9766 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
9767 9767 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9768 9768 $as_echo_n "checking for MV... " >&6; }
9769 9769 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9770 9770 $as_echo "disabled" >&6; }
9771 9771 else
9772 9772 # Check if the provided tool contains a complete path.
9773 9773 tool_specified="$MV"
9774 9774 tool_basename="${tool_specified##*/}"
9775 9775 if test "x$tool_basename" = "x$tool_specified"; then
9776 9776 # A command without a complete path is provided, search $PATH.
9777 9777 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
9778 9778 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
9779 9779 # Extract the first word of "$tool_basename", so it can be a program name with args.
9780 9780 set dummy $tool_basename; ac_word=$2
9781 9781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9782 9782 $as_echo_n "checking for $ac_word... " >&6; }
9783 9783 if ${ac_cv_path_MV+:} false; then :
9784 9784 $as_echo_n "(cached) " >&6
9785 9785 else
9786 9786 case $MV in
9787 9787 [\\/]* | ?:[\\/]*)
9788 9788 ac_cv_path_MV="$MV" # Let the user override the test with a path.
9789 9789 ;;
9790 9790 *)
9791 9791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9792 9792 for as_dir in $PATH
9793 9793 do
9794 9794 IFS=$as_save_IFS
9795 9795 test -z "$as_dir" && as_dir=.
9796 9796 for ac_exec_ext in '' $ac_executable_extensions; do
9797 9797 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9798 9798 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9799 9799 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9800 9800 break 2
9801 9801 fi
9802 9802 done
9803 9803 done
9804 9804 IFS=$as_save_IFS
9805 9805
9806 9806 ;;
9807 9807 esac
9808 9808 fi
9809 9809 MV=$ac_cv_path_MV
9810 9810 if test -n "$MV"; then
9811 9811 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9812 9812 $as_echo "$MV" >&6; }
9813 9813 else
9814 9814 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9815 9815 $as_echo "no" >&6; }
9816 9816 fi
9817 9817
9818 9818
9819 9819 if test "x$MV" = x; then
9820 9820 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9821 9821 fi
9822 9822 else
9823 9823 # Otherwise we believe it is a complete path. Use it as it is.
9824 9824 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9825 9825 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9826 9826 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9827 9827 $as_echo_n "checking for MV... " >&6; }
9828 9828 if test ! -x "$tool_specified"; then
9829 9829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9830 9830 $as_echo "not found" >&6; }
9831 9831 as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9832 9832 fi
9833 9833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9834 9834 $as_echo "$tool_specified" >&6; }
9835 9835 fi
9836 9836 fi
9837 9837 fi
9838 9838
9839 9839 fi
9840 9840
9841 9841
9842 9842
9843 9843 if test "x$MV" = x; then
9844 9844 as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9845 9845 fi
9846 9846
9847 9847
9848 9848
9849 9849
9850 9850
9851 9851 # Publish this variable in the help.
9852 9852
9853 9853
9854 9854 if [ -z "${NAWK+x}" ]; then
9855 9855 # The variable is not set by user, try to locate tool using the code snippet
9856 9856 for ac_prog in nawk gawk awk
9857 9857 do
9858 9858 # Extract the first word of "$ac_prog", so it can be a program name with args.
9859 9859 set dummy $ac_prog; ac_word=$2
9860 9860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9861 9861 $as_echo_n "checking for $ac_word... " >&6; }
9862 9862 if ${ac_cv_path_NAWK+:} false; then :
9863 9863 $as_echo_n "(cached) " >&6
9864 9864 else
9865 9865 case $NAWK in
9866 9866 [\\/]* | ?:[\\/]*)
9867 9867 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9868 9868 ;;
9869 9869 *)
9870 9870 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9871 9871 for as_dir in $PATH
9872 9872 do
9873 9873 IFS=$as_save_IFS
9874 9874 test -z "$as_dir" && as_dir=.
9875 9875 for ac_exec_ext in '' $ac_executable_extensions; do
9876 9876 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9877 9877 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9878 9878 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9879 9879 break 2
9880 9880 fi
9881 9881 done
9882 9882 done
9883 9883 IFS=$as_save_IFS
9884 9884
9885 9885 ;;
9886 9886 esac
9887 9887 fi
9888 9888 NAWK=$ac_cv_path_NAWK
9889 9889 if test -n "$NAWK"; then
9890 9890 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9891 9891 $as_echo "$NAWK" >&6; }
9892 9892 else
9893 9893 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9894 9894 $as_echo "no" >&6; }
9895 9895 fi
9896 9896
9897 9897
9898 9898 test -n "$NAWK" && break
9899 9899 done
9900 9900
9901 9901 else
9902 9902 # The variable is set, but is it from the command line or the environment?
9903 9903
9904 9904 # Try to remove the string !NAWK! from our list.
9905 9905 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9906 9906 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9907 9907 # If it failed, the variable was not from the command line. Ignore it,
9908 9908 # but warn the user (except for BASH, which is always set by the calling BASH).
9909 9909 if test "xNAWK" != xBASH; then
9910 9910 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9911 9911 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9912 9912 fi
9913 9913 # Try to locate tool using the code snippet
9914 9914 for ac_prog in nawk gawk awk
9915 9915 do
9916 9916 # Extract the first word of "$ac_prog", so it can be a program name with args.
9917 9917 set dummy $ac_prog; ac_word=$2
9918 9918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9919 9919 $as_echo_n "checking for $ac_word... " >&6; }
9920 9920 if ${ac_cv_path_NAWK+:} false; then :
9921 9921 $as_echo_n "(cached) " >&6
9922 9922 else
9923 9923 case $NAWK in
9924 9924 [\\/]* | ?:[\\/]*)
9925 9925 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9926 9926 ;;
9927 9927 *)
9928 9928 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9929 9929 for as_dir in $PATH
9930 9930 do
9931 9931 IFS=$as_save_IFS
9932 9932 test -z "$as_dir" && as_dir=.
9933 9933 for ac_exec_ext in '' $ac_executable_extensions; do
9934 9934 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9935 9935 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9936 9936 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9937 9937 break 2
9938 9938 fi
9939 9939 done
9940 9940 done
9941 9941 IFS=$as_save_IFS
9942 9942
9943 9943 ;;
9944 9944 esac
9945 9945 fi
9946 9946 NAWK=$ac_cv_path_NAWK
9947 9947 if test -n "$NAWK"; then
9948 9948 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9949 9949 $as_echo "$NAWK" >&6; }
9950 9950 else
9951 9951 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9952 9952 $as_echo "no" >&6; }
9953 9953 fi
9954 9954
9955 9955
9956 9956 test -n "$NAWK" && break
9957 9957 done
9958 9958
9959 9959 else
9960 9960 # If it succeeded, then it was overridden by the user. We will use it
9961 9961 # for the tool.
9962 9962
9963 9963 # First remove it from the list of overridden variables, so we can test
9964 9964 # for unknown variables in the end.
9965 9965 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9966 9966
9967 9967 # Check if we try to supply an empty value
9968 9968 if test "x$NAWK" = x; then
9969 9969 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9970 9970 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9971 9971 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9972 9972 $as_echo_n "checking for NAWK... " >&6; }
9973 9973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9974 9974 $as_echo "disabled" >&6; }
9975 9975 else
9976 9976 # Check if the provided tool contains a complete path.
9977 9977 tool_specified="$NAWK"
9978 9978 tool_basename="${tool_specified##*/}"
9979 9979 if test "x$tool_basename" = "x$tool_specified"; then
9980 9980 # A command without a complete path is provided, search $PATH.
9981 9981 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9982 9982 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9983 9983 # Extract the first word of "$tool_basename", so it can be a program name with args.
9984 9984 set dummy $tool_basename; ac_word=$2
9985 9985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9986 9986 $as_echo_n "checking for $ac_word... " >&6; }
9987 9987 if ${ac_cv_path_NAWK+:} false; then :
9988 9988 $as_echo_n "(cached) " >&6
9989 9989 else
9990 9990 case $NAWK in
9991 9991 [\\/]* | ?:[\\/]*)
9992 9992 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9993 9993 ;;
9994 9994 *)
9995 9995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9996 9996 for as_dir in $PATH
9997 9997 do
9998 9998 IFS=$as_save_IFS
9999 9999 test -z "$as_dir" && as_dir=.
10000 10000 for ac_exec_ext in '' $ac_executable_extensions; do
10001 10001 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10002 10002 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
10003 10003 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10004 10004 break 2
10005 10005 fi
10006 10006 done
10007 10007 done
10008 10008 IFS=$as_save_IFS
10009 10009
10010 10010 ;;
10011 10011 esac
10012 10012 fi
10013 10013 NAWK=$ac_cv_path_NAWK
10014 10014 if test -n "$NAWK"; then
10015 10015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
10016 10016 $as_echo "$NAWK" >&6; }
10017 10017 else
10018 10018 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10019 10019 $as_echo "no" >&6; }
10020 10020 fi
10021 10021
10022 10022
10023 10023 if test "x$NAWK" = x; then
10024 10024 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10025 10025 fi
10026 10026 else
10027 10027 # Otherwise we believe it is a complete path. Use it as it is.
10028 10028 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
10029 10029 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
10030 10030 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
10031 10031 $as_echo_n "checking for NAWK... " >&6; }
10032 10032 if test ! -x "$tool_specified"; then
10033 10033 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10034 10034 $as_echo "not found" >&6; }
10035 10035 as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
10036 10036 fi
10037 10037 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10038 10038 $as_echo "$tool_specified" >&6; }
10039 10039 fi
10040 10040 fi
10041 10041 fi
10042 10042
10043 10043 fi
10044 10044
10045 10045
10046 10046
10047 10047 if test "x$NAWK" = x; then
10048 10048 as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
10049 10049 fi
10050 10050
10051 10051
10052 10052
10053 10053
10054 10054
10055 10055 # Publish this variable in the help.
10056 10056
10057 10057
10058 10058 if [ -z "${PRINTF+x}" ]; then
10059 10059 # The variable is not set by user, try to locate tool using the code snippet
10060 10060 for ac_prog in printf
10061 10061 do
10062 10062 # Extract the first word of "$ac_prog", so it can be a program name with args.
10063 10063 set dummy $ac_prog; ac_word=$2
10064 10064 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10065 10065 $as_echo_n "checking for $ac_word... " >&6; }
10066 10066 if ${ac_cv_path_PRINTF+:} false; then :
10067 10067 $as_echo_n "(cached) " >&6
10068 10068 else
10069 10069 case $PRINTF in
10070 10070 [\\/]* | ?:[\\/]*)
10071 10071 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10072 10072 ;;
10073 10073 *)
10074 10074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10075 10075 for as_dir in $PATH
10076 10076 do
10077 10077 IFS=$as_save_IFS
10078 10078 test -z "$as_dir" && as_dir=.
10079 10079 for ac_exec_ext in '' $ac_executable_extensions; do
10080 10080 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10081 10081 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10082 10082 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10083 10083 break 2
10084 10084 fi
10085 10085 done
10086 10086 done
10087 10087 IFS=$as_save_IFS
10088 10088
10089 10089 ;;
10090 10090 esac
10091 10091 fi
10092 10092 PRINTF=$ac_cv_path_PRINTF
10093 10093 if test -n "$PRINTF"; then
10094 10094 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10095 10095 $as_echo "$PRINTF" >&6; }
10096 10096 else
10097 10097 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10098 10098 $as_echo "no" >&6; }
10099 10099 fi
10100 10100
10101 10101
10102 10102 test -n "$PRINTF" && break
10103 10103 done
10104 10104
10105 10105 else
10106 10106 # The variable is set, but is it from the command line or the environment?
10107 10107
10108 10108 # Try to remove the string !PRINTF! from our list.
10109 10109 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
10110 10110 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10111 10111 # If it failed, the variable was not from the command line. Ignore it,
10112 10112 # but warn the user (except for BASH, which is always set by the calling BASH).
10113 10113 if test "xPRINTF" != xBASH; then
10114 10114 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
10115 10115 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
10116 10116 fi
10117 10117 # Try to locate tool using the code snippet
10118 10118 for ac_prog in printf
10119 10119 do
10120 10120 # Extract the first word of "$ac_prog", so it can be a program name with args.
10121 10121 set dummy $ac_prog; ac_word=$2
10122 10122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10123 10123 $as_echo_n "checking for $ac_word... " >&6; }
10124 10124 if ${ac_cv_path_PRINTF+:} false; then :
10125 10125 $as_echo_n "(cached) " >&6
10126 10126 else
10127 10127 case $PRINTF in
10128 10128 [\\/]* | ?:[\\/]*)
10129 10129 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10130 10130 ;;
10131 10131 *)
10132 10132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10133 10133 for as_dir in $PATH
10134 10134 do
10135 10135 IFS=$as_save_IFS
10136 10136 test -z "$as_dir" && as_dir=.
10137 10137 for ac_exec_ext in '' $ac_executable_extensions; do
10138 10138 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10139 10139 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10140 10140 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10141 10141 break 2
10142 10142 fi
10143 10143 done
10144 10144 done
10145 10145 IFS=$as_save_IFS
10146 10146
10147 10147 ;;
10148 10148 esac
10149 10149 fi
10150 10150 PRINTF=$ac_cv_path_PRINTF
10151 10151 if test -n "$PRINTF"; then
10152 10152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10153 10153 $as_echo "$PRINTF" >&6; }
10154 10154 else
10155 10155 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10156 10156 $as_echo "no" >&6; }
10157 10157 fi
10158 10158
10159 10159
10160 10160 test -n "$PRINTF" && break
10161 10161 done
10162 10162
10163 10163 else
10164 10164 # If it succeeded, then it was overridden by the user. We will use it
10165 10165 # for the tool.
10166 10166
10167 10167 # First remove it from the list of overridden variables, so we can test
10168 10168 # for unknown variables in the end.
10169 10169 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10170 10170
10171 10171 # Check if we try to supply an empty value
10172 10172 if test "x$PRINTF" = x; then
10173 10173 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
10174 10174 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
10175 10175 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10176 10176 $as_echo_n "checking for PRINTF... " >&6; }
10177 10177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10178 10178 $as_echo "disabled" >&6; }
10179 10179 else
10180 10180 # Check if the provided tool contains a complete path.
10181 10181 tool_specified="$PRINTF"
10182 10182 tool_basename="${tool_specified##*/}"
10183 10183 if test "x$tool_basename" = "x$tool_specified"; then
10184 10184 # A command without a complete path is provided, search $PATH.
10185 10185 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
10186 10186 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
10187 10187 # Extract the first word of "$tool_basename", so it can be a program name with args.
10188 10188 set dummy $tool_basename; ac_word=$2
10189 10189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10190 10190 $as_echo_n "checking for $ac_word... " >&6; }
10191 10191 if ${ac_cv_path_PRINTF+:} false; then :
10192 10192 $as_echo_n "(cached) " >&6
10193 10193 else
10194 10194 case $PRINTF in
10195 10195 [\\/]* | ?:[\\/]*)
10196 10196 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10197 10197 ;;
10198 10198 *)
10199 10199 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10200 10200 for as_dir in $PATH
10201 10201 do
10202 10202 IFS=$as_save_IFS
10203 10203 test -z "$as_dir" && as_dir=.
10204 10204 for ac_exec_ext in '' $ac_executable_extensions; do
10205 10205 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10206 10206 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10207 10207 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10208 10208 break 2
10209 10209 fi
10210 10210 done
10211 10211 done
10212 10212 IFS=$as_save_IFS
10213 10213
10214 10214 ;;
10215 10215 esac
10216 10216 fi
10217 10217 PRINTF=$ac_cv_path_PRINTF
10218 10218 if test -n "$PRINTF"; then
10219 10219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10220 10220 $as_echo "$PRINTF" >&6; }
10221 10221 else
10222 10222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10223 10223 $as_echo "no" >&6; }
10224 10224 fi
10225 10225
10226 10226
10227 10227 if test "x$PRINTF" = x; then
10228 10228 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10229 10229 fi
10230 10230 else
10231 10231 # Otherwise we believe it is a complete path. Use it as it is.
10232 10232 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
10233 10233 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
10234 10234 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10235 10235 $as_echo_n "checking for PRINTF... " >&6; }
10236 10236 if test ! -x "$tool_specified"; then
10237 10237 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10238 10238 $as_echo "not found" >&6; }
10239 10239 as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
10240 10240 fi
10241 10241 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10242 10242 $as_echo "$tool_specified" >&6; }
10243 10243 fi
10244 10244 fi
10245 10245 fi
10246 10246
10247 10247 fi
10248 10248
10249 10249
10250 10250
10251 10251 if test "x$PRINTF" = x; then
10252 10252 as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
10253 10253 fi
10254 10254
10255 10255
10256 10256
10257 10257
10258 10258
10259 10259 # Publish this variable in the help.
10260 10260
10261 10261
10262 10262 if [ -z "${RM+x}" ]; then
10263 10263 # The variable is not set by user, try to locate tool using the code snippet
10264 10264 for ac_prog in rm
10265 10265 do
10266 10266 # Extract the first word of "$ac_prog", so it can be a program name with args.
10267 10267 set dummy $ac_prog; ac_word=$2
10268 10268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10269 10269 $as_echo_n "checking for $ac_word... " >&6; }
10270 10270 if ${ac_cv_path_RM+:} false; then :
10271 10271 $as_echo_n "(cached) " >&6
10272 10272 else
10273 10273 case $RM in
10274 10274 [\\/]* | ?:[\\/]*)
10275 10275 ac_cv_path_RM="$RM" # Let the user override the test with a path.
10276 10276 ;;
10277 10277 *)
10278 10278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10279 10279 for as_dir in $PATH
10280 10280 do
10281 10281 IFS=$as_save_IFS
10282 10282 test -z "$as_dir" && as_dir=.
10283 10283 for ac_exec_ext in '' $ac_executable_extensions; do
10284 10284 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10285 10285 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10286 10286 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10287 10287 break 2
10288 10288 fi
10289 10289 done
10290 10290 done
10291 10291 IFS=$as_save_IFS
10292 10292
10293 10293 ;;
10294 10294 esac
10295 10295 fi
10296 10296 RM=$ac_cv_path_RM
10297 10297 if test -n "$RM"; then
10298 10298 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10299 10299 $as_echo "$RM" >&6; }
10300 10300 else
10301 10301 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10302 10302 $as_echo "no" >&6; }
10303 10303 fi
10304 10304
10305 10305
10306 10306 test -n "$RM" && break
10307 10307 done
10308 10308
10309 10309 else
10310 10310 # The variable is set, but is it from the command line or the environment?
10311 10311
10312 10312 # Try to remove the string !RM! from our list.
10313 10313 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
10314 10314 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10315 10315 # If it failed, the variable was not from the command line. Ignore it,
10316 10316 # but warn the user (except for BASH, which is always set by the calling BASH).
10317 10317 if test "xRM" != xBASH; then
10318 10318 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
10319 10319 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
10320 10320 fi
10321 10321 # Try to locate tool using the code snippet
10322 10322 for ac_prog in rm
10323 10323 do
10324 10324 # Extract the first word of "$ac_prog", so it can be a program name with args.
10325 10325 set dummy $ac_prog; ac_word=$2
10326 10326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10327 10327 $as_echo_n "checking for $ac_word... " >&6; }
10328 10328 if ${ac_cv_path_RM+:} false; then :
10329 10329 $as_echo_n "(cached) " >&6
10330 10330 else
10331 10331 case $RM in
10332 10332 [\\/]* | ?:[\\/]*)
10333 10333 ac_cv_path_RM="$RM" # Let the user override the test with a path.
10334 10334 ;;
10335 10335 *)
10336 10336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10337 10337 for as_dir in $PATH
10338 10338 do
10339 10339 IFS=$as_save_IFS
10340 10340 test -z "$as_dir" && as_dir=.
10341 10341 for ac_exec_ext in '' $ac_executable_extensions; do
10342 10342 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10343 10343 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10344 10344 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10345 10345 break 2
10346 10346 fi
10347 10347 done
10348 10348 done
10349 10349 IFS=$as_save_IFS
10350 10350
10351 10351 ;;
10352 10352 esac
10353 10353 fi
10354 10354 RM=$ac_cv_path_RM
10355 10355 if test -n "$RM"; then
10356 10356 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10357 10357 $as_echo "$RM" >&6; }
10358 10358 else
10359 10359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10360 10360 $as_echo "no" >&6; }
10361 10361 fi
10362 10362
10363 10363
10364 10364 test -n "$RM" && break
10365 10365 done
10366 10366
10367 10367 else
10368 10368 # If it succeeded, then it was overridden by the user. We will use it
10369 10369 # for the tool.
10370 10370
10371 10371 # First remove it from the list of overridden variables, so we can test
10372 10372 # for unknown variables in the end.
10373 10373 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10374 10374
10375 10375 # Check if we try to supply an empty value
10376 10376 if test "x$RM" = x; then
10377 10377 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
10378 10378 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
10379 10379 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10380 10380 $as_echo_n "checking for RM... " >&6; }
10381 10381 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10382 10382 $as_echo "disabled" >&6; }
10383 10383 else
10384 10384 # Check if the provided tool contains a complete path.
10385 10385 tool_specified="$RM"
10386 10386 tool_basename="${tool_specified##*/}"
10387 10387 if test "x$tool_basename" = "x$tool_specified"; then
10388 10388 # A command without a complete path is provided, search $PATH.
10389 10389 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
10390 10390 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
10391 10391 # Extract the first word of "$tool_basename", so it can be a program name with args.
10392 10392 set dummy $tool_basename; ac_word=$2
10393 10393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10394 10394 $as_echo_n "checking for $ac_word... " >&6; }
10395 10395 if ${ac_cv_path_RM+:} false; then :
10396 10396 $as_echo_n "(cached) " >&6
10397 10397 else
10398 10398 case $RM in
10399 10399 [\\/]* | ?:[\\/]*)
10400 10400 ac_cv_path_RM="$RM" # Let the user override the test with a path.
10401 10401 ;;
10402 10402 *)
10403 10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 10404 for as_dir in $PATH
10405 10405 do
10406 10406 IFS=$as_save_IFS
10407 10407 test -z "$as_dir" && as_dir=.
10408 10408 for ac_exec_ext in '' $ac_executable_extensions; do
10409 10409 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410 10410 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10411 10411 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10412 10412 break 2
10413 10413 fi
10414 10414 done
10415 10415 done
10416 10416 IFS=$as_save_IFS
10417 10417
10418 10418 ;;
10419 10419 esac
10420 10420 fi
10421 10421 RM=$ac_cv_path_RM
10422 10422 if test -n "$RM"; then
10423 10423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10424 10424 $as_echo "$RM" >&6; }
10425 10425 else
10426 10426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10427 10427 $as_echo "no" >&6; }
10428 10428 fi
10429 10429
10430 10430
10431 10431 if test "x$RM" = x; then
10432 10432 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10433 10433 fi
10434 10434 else
10435 10435 # Otherwise we believe it is a complete path. Use it as it is.
10436 10436 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
10437 10437 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
10438 10438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10439 10439 $as_echo_n "checking for RM... " >&6; }
10440 10440 if test ! -x "$tool_specified"; then
10441 10441 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10442 10442 $as_echo "not found" >&6; }
10443 10443 as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
10444 10444 fi
10445 10445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10446 10446 $as_echo "$tool_specified" >&6; }
10447 10447 fi
10448 10448 fi
10449 10449 fi
10450 10450
10451 10451 fi
10452 10452
10453 10453
10454 10454
10455 10455 if test "x$RM" = x; then
10456 10456 as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
10457 10457 fi
10458 10458
10459 10459
10460 10460
10461 10461
10462 10462
10463 10463 # Publish this variable in the help.
10464 10464
10465 10465
10466 10466 if [ -z "${RMDIR+x}" ]; then
10467 10467 # The variable is not set by user, try to locate tool using the code snippet
10468 10468 for ac_prog in rmdir
10469 10469 do
10470 10470 # Extract the first word of "$ac_prog", so it can be a program name with args.
10471 10471 set dummy $ac_prog; ac_word=$2
10472 10472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10473 10473 $as_echo_n "checking for $ac_word... " >&6; }
10474 10474 if ${ac_cv_path_RMDIR+:} false; then :
10475 10475 $as_echo_n "(cached) " >&6
10476 10476 else
10477 10477 case $RMDIR in
10478 10478 [\\/]* | ?:[\\/]*)
10479 10479 ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10480 10480 ;;
10481 10481 *)
10482 10482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10483 10483 for as_dir in $PATH
10484 10484 do
10485 10485 IFS=$as_save_IFS
10486 10486 test -z "$as_dir" && as_dir=.
10487 10487 for ac_exec_ext in '' $ac_executable_extensions; do
10488 10488 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10489 10489 ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10490 10490 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10491 10491 break 2
10492 10492 fi
10493 10493 done
10494 10494 done
10495 10495 IFS=$as_save_IFS
10496 10496
10497 10497 ;;
10498 10498 esac
10499 10499 fi
10500 10500 RMDIR=$ac_cv_path_RMDIR
10501 10501 if test -n "$RMDIR"; then
10502 10502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10503 10503 $as_echo "$RMDIR" >&6; }
10504 10504 else
10505 10505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10506 10506 $as_echo "no" >&6; }
10507 10507 fi
10508 10508
10509 10509
10510 10510 test -n "$RMDIR" && break
10511 10511 done
10512 10512
10513 10513 else
10514 10514 # The variable is set, but is it from the command line or the environment?
10515 10515
10516 10516 # Try to remove the string !RMDIR! from our list.
10517 10517 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
10518 10518 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10519 10519 # If it failed, the variable was not from the command line. Ignore it,
10520 10520 # but warn the user (except for BASH, which is always set by the calling BASH).
10521 10521 if test "xRMDIR" != xBASH; then
10522 10522 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
10523 10523 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
10524 10524 fi
10525 10525 # Try to locate tool using the code snippet
10526 10526 for ac_prog in rmdir
10527 10527 do
10528 10528 # Extract the first word of "$ac_prog", so it can be a program name with args.
10529 10529 set dummy $ac_prog; ac_word=$2
10530 10530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10531 10531 $as_echo_n "checking for $ac_word... " >&6; }
10532 10532 if ${ac_cv_path_RMDIR+:} false; then :
10533 10533 $as_echo_n "(cached) " >&6
10534 10534 else
10535 10535 case $RMDIR in
10536 10536 [\\/]* | ?:[\\/]*)
10537 10537 ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10538 10538 ;;
10539 10539 *)
10540 10540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10541 10541 for as_dir in $PATH
10542 10542 do
10543 10543 IFS=$as_save_IFS
10544 10544 test -z "$as_dir" && as_dir=.
10545 10545 for ac_exec_ext in '' $ac_executable_extensions; do
10546 10546 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10547 10547 ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10548 10548 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10549 10549 break 2
10550 10550 fi
10551 10551 done
10552 10552 done
10553 10553 IFS=$as_save_IFS
10554 10554
10555 10555 ;;
10556 10556 esac
10557 10557 fi
10558 10558 RMDIR=$ac_cv_path_RMDIR
10559 10559 if test -n "$RMDIR"; then
10560 10560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10561 10561 $as_echo "$RMDIR" >&6; }
10562 10562 else
10563 10563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10564 10564 $as_echo "no" >&6; }
10565 10565 fi
10566 10566
10567 10567
10568 10568 test -n "$RMDIR" && break
10569 10569 done
10570 10570
10571 10571 else
10572 10572 # If it succeeded, then it was overridden by the user. We will use it
10573 10573 # for the tool.
10574 10574
10575 10575 # First remove it from the list of overridden variables, so we can test
10576 10576 # for unknown variables in the end.
10577 10577 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10578 10578
10579 10579 # Check if we try to supply an empty value
10580 10580 if test "x$RMDIR" = x; then
10581 10581 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
10582 10582 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
10583 10583 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10584 10584 $as_echo_n "checking for RMDIR... " >&6; }
10585 10585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10586 10586 $as_echo "disabled" >&6; }
10587 10587 else
10588 10588 # Check if the provided tool contains a complete path.
10589 10589 tool_specified="$RMDIR"
10590 10590 tool_basename="${tool_specified##*/}"
10591 10591 if test "x$tool_basename" = "x$tool_specified"; then
10592 10592 # A command without a complete path is provided, search $PATH.
10593 10593 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
10594 10594 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
10595 10595 # Extract the first word of "$tool_basename", so it can be a program name with args.
10596 10596 set dummy $tool_basename; ac_word=$2
10597 10597 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10598 10598 $as_echo_n "checking for $ac_word... " >&6; }
10599 10599 if ${ac_cv_path_RMDIR+:} false; then :
10600 10600 $as_echo_n "(cached) " >&6
10601 10601 else
10602 10602 case $RMDIR in
10603 10603 [\\/]* | ?:[\\/]*)
10604 10604 ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10605 10605 ;;
10606 10606 *)
10607 10607 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10608 10608 for as_dir in $PATH
10609 10609 do
10610 10610 IFS=$as_save_IFS
10611 10611 test -z "$as_dir" && as_dir=.
10612 10612 for ac_exec_ext in '' $ac_executable_extensions; do
10613 10613 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10614 10614 ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10615 10615 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10616 10616 break 2
10617 10617 fi
10618 10618 done
10619 10619 done
10620 10620 IFS=$as_save_IFS
10621 10621
10622 10622 ;;
10623 10623 esac
10624 10624 fi
10625 10625 RMDIR=$ac_cv_path_RMDIR
10626 10626 if test -n "$RMDIR"; then
10627 10627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10628 10628 $as_echo "$RMDIR" >&6; }
10629 10629 else
10630 10630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10631 10631 $as_echo "no" >&6; }
10632 10632 fi
10633 10633
10634 10634
10635 10635 if test "x$RMDIR" = x; then
10636 10636 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10637 10637 fi
10638 10638 else
10639 10639 # Otherwise we believe it is a complete path. Use it as it is.
10640 10640 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
10641 10641 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
10642 10642 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10643 10643 $as_echo_n "checking for RMDIR... " >&6; }
10644 10644 if test ! -x "$tool_specified"; then
10645 10645 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10646 10646 $as_echo "not found" >&6; }
10647 10647 as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
10648 10648 fi
10649 10649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10650 10650 $as_echo "$tool_specified" >&6; }
10651 10651 fi
10652 10652 fi
10653 10653 fi
10654 10654
10655 10655 fi
10656 10656
10657 10657
10658 10658
10659 10659 if test "x$RMDIR" = x; then
10660 10660 as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
10661 10661 fi
10662 10662
10663 10663
10664 10664
10665 10665
10666 10666
10667 10667 # Publish this variable in the help.
10668 10668
10669 10669
10670 10670 if [ -z "${SH+x}" ]; then
10671 10671 # The variable is not set by user, try to locate tool using the code snippet
10672 10672 for ac_prog in sh
10673 10673 do
10674 10674 # Extract the first word of "$ac_prog", so it can be a program name with args.
10675 10675 set dummy $ac_prog; ac_word=$2
10676 10676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10677 10677 $as_echo_n "checking for $ac_word... " >&6; }
10678 10678 if ${ac_cv_path_SH+:} false; then :
10679 10679 $as_echo_n "(cached) " >&6
10680 10680 else
10681 10681 case $SH in
10682 10682 [\\/]* | ?:[\\/]*)
10683 10683 ac_cv_path_SH="$SH" # Let the user override the test with a path.
10684 10684 ;;
10685 10685 *)
10686 10686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10687 10687 for as_dir in $PATH
10688 10688 do
10689 10689 IFS=$as_save_IFS
10690 10690 test -z "$as_dir" && as_dir=.
10691 10691 for ac_exec_ext in '' $ac_executable_extensions; do
10692 10692 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10693 10693 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10694 10694 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10695 10695 break 2
10696 10696 fi
10697 10697 done
10698 10698 done
10699 10699 IFS=$as_save_IFS
10700 10700
10701 10701 ;;
10702 10702 esac
10703 10703 fi
10704 10704 SH=$ac_cv_path_SH
10705 10705 if test -n "$SH"; then
10706 10706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10707 10707 $as_echo "$SH" >&6; }
10708 10708 else
10709 10709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10710 10710 $as_echo "no" >&6; }
10711 10711 fi
10712 10712
10713 10713
10714 10714 test -n "$SH" && break
10715 10715 done
10716 10716
10717 10717 else
10718 10718 # The variable is set, but is it from the command line or the environment?
10719 10719
10720 10720 # Try to remove the string !SH! from our list.
10721 10721 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
10722 10722 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10723 10723 # If it failed, the variable was not from the command line. Ignore it,
10724 10724 # but warn the user (except for BASH, which is always set by the calling BASH).
10725 10725 if test "xSH" != xBASH; then
10726 10726 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
10727 10727 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
10728 10728 fi
10729 10729 # Try to locate tool using the code snippet
10730 10730 for ac_prog in sh
10731 10731 do
10732 10732 # Extract the first word of "$ac_prog", so it can be a program name with args.
10733 10733 set dummy $ac_prog; ac_word=$2
10734 10734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10735 10735 $as_echo_n "checking for $ac_word... " >&6; }
10736 10736 if ${ac_cv_path_SH+:} false; then :
10737 10737 $as_echo_n "(cached) " >&6
10738 10738 else
10739 10739 case $SH in
10740 10740 [\\/]* | ?:[\\/]*)
10741 10741 ac_cv_path_SH="$SH" # Let the user override the test with a path.
10742 10742 ;;
10743 10743 *)
10744 10744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10745 10745 for as_dir in $PATH
10746 10746 do
10747 10747 IFS=$as_save_IFS
10748 10748 test -z "$as_dir" && as_dir=.
10749 10749 for ac_exec_ext in '' $ac_executable_extensions; do
10750 10750 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10751 10751 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10752 10752 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10753 10753 break 2
10754 10754 fi
10755 10755 done
10756 10756 done
10757 10757 IFS=$as_save_IFS
10758 10758
10759 10759 ;;
10760 10760 esac
10761 10761 fi
10762 10762 SH=$ac_cv_path_SH
10763 10763 if test -n "$SH"; then
10764 10764 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10765 10765 $as_echo "$SH" >&6; }
10766 10766 else
10767 10767 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10768 10768 $as_echo "no" >&6; }
10769 10769 fi
10770 10770
10771 10771
10772 10772 test -n "$SH" && break
10773 10773 done
10774 10774
10775 10775 else
10776 10776 # If it succeeded, then it was overridden by the user. We will use it
10777 10777 # for the tool.
10778 10778
10779 10779 # First remove it from the list of overridden variables, so we can test
10780 10780 # for unknown variables in the end.
10781 10781 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10782 10782
10783 10783 # Check if we try to supply an empty value
10784 10784 if test "x$SH" = x; then
10785 10785 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
10786 10786 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
10787 10787 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10788 10788 $as_echo_n "checking for SH... " >&6; }
10789 10789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10790 10790 $as_echo "disabled" >&6; }
10791 10791 else
10792 10792 # Check if the provided tool contains a complete path.
10793 10793 tool_specified="$SH"
10794 10794 tool_basename="${tool_specified##*/}"
10795 10795 if test "x$tool_basename" = "x$tool_specified"; then
10796 10796 # A command without a complete path is provided, search $PATH.
10797 10797 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
10798 10798 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
10799 10799 # Extract the first word of "$tool_basename", so it can be a program name with args.
10800 10800 set dummy $tool_basename; ac_word=$2
10801 10801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10802 10802 $as_echo_n "checking for $ac_word... " >&6; }
10803 10803 if ${ac_cv_path_SH+:} false; then :
10804 10804 $as_echo_n "(cached) " >&6
10805 10805 else
10806 10806 case $SH in
10807 10807 [\\/]* | ?:[\\/]*)
10808 10808 ac_cv_path_SH="$SH" # Let the user override the test with a path.
10809 10809 ;;
10810 10810 *)
10811 10811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10812 10812 for as_dir in $PATH
10813 10813 do
10814 10814 IFS=$as_save_IFS
10815 10815 test -z "$as_dir" && as_dir=.
10816 10816 for ac_exec_ext in '' $ac_executable_extensions; do
10817 10817 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10818 10818 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10819 10819 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10820 10820 break 2
10821 10821 fi
10822 10822 done
10823 10823 done
10824 10824 IFS=$as_save_IFS
10825 10825
10826 10826 ;;
10827 10827 esac
10828 10828 fi
10829 10829 SH=$ac_cv_path_SH
10830 10830 if test -n "$SH"; then
10831 10831 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10832 10832 $as_echo "$SH" >&6; }
10833 10833 else
10834 10834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10835 10835 $as_echo "no" >&6; }
10836 10836 fi
10837 10837
10838 10838
10839 10839 if test "x$SH" = x; then
10840 10840 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10841 10841 fi
10842 10842 else
10843 10843 # Otherwise we believe it is a complete path. Use it as it is.
10844 10844 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10845 10845 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10846 10846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10847 10847 $as_echo_n "checking for SH... " >&6; }
10848 10848 if test ! -x "$tool_specified"; then
10849 10849 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10850 10850 $as_echo "not found" >&6; }
10851 10851 as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10852 10852 fi
10853 10853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10854 10854 $as_echo "$tool_specified" >&6; }
10855 10855 fi
10856 10856 fi
10857 10857 fi
10858 10858
10859 10859 fi
10860 10860
10861 10861
10862 10862
10863 10863 if test "x$SH" = x; then
10864 10864 as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10865 10865 fi
10866 10866
10867 10867
10868 10868
10869 10869
10870 10870
10871 10871 # Publish this variable in the help.
10872 10872
10873 10873
10874 10874 if [ -z "${SORT+x}" ]; then
10875 10875 # The variable is not set by user, try to locate tool using the code snippet
10876 10876 for ac_prog in sort
10877 10877 do
10878 10878 # Extract the first word of "$ac_prog", so it can be a program name with args.
10879 10879 set dummy $ac_prog; ac_word=$2
10880 10880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10881 10881 $as_echo_n "checking for $ac_word... " >&6; }
10882 10882 if ${ac_cv_path_SORT+:} false; then :
10883 10883 $as_echo_n "(cached) " >&6
10884 10884 else
10885 10885 case $SORT in
10886 10886 [\\/]* | ?:[\\/]*)
10887 10887 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10888 10888 ;;
10889 10889 *)
10890 10890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10891 10891 for as_dir in $PATH
10892 10892 do
10893 10893 IFS=$as_save_IFS
10894 10894 test -z "$as_dir" && as_dir=.
10895 10895 for ac_exec_ext in '' $ac_executable_extensions; do
10896 10896 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10897 10897 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10898 10898 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10899 10899 break 2
10900 10900 fi
10901 10901 done
10902 10902 done
10903 10903 IFS=$as_save_IFS
10904 10904
10905 10905 ;;
10906 10906 esac
10907 10907 fi
10908 10908 SORT=$ac_cv_path_SORT
10909 10909 if test -n "$SORT"; then
10910 10910 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10911 10911 $as_echo "$SORT" >&6; }
10912 10912 else
10913 10913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10914 10914 $as_echo "no" >&6; }
10915 10915 fi
10916 10916
10917 10917
10918 10918 test -n "$SORT" && break
10919 10919 done
10920 10920
10921 10921 else
10922 10922 # The variable is set, but is it from the command line or the environment?
10923 10923
10924 10924 # Try to remove the string !SORT! from our list.
10925 10925 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10926 10926 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10927 10927 # If it failed, the variable was not from the command line. Ignore it,
10928 10928 # but warn the user (except for BASH, which is always set by the calling BASH).
10929 10929 if test "xSORT" != xBASH; then
10930 10930 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10931 10931 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10932 10932 fi
10933 10933 # Try to locate tool using the code snippet
10934 10934 for ac_prog in sort
10935 10935 do
10936 10936 # Extract the first word of "$ac_prog", so it can be a program name with args.
10937 10937 set dummy $ac_prog; ac_word=$2
10938 10938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10939 10939 $as_echo_n "checking for $ac_word... " >&6; }
10940 10940 if ${ac_cv_path_SORT+:} false; then :
10941 10941 $as_echo_n "(cached) " >&6
10942 10942 else
10943 10943 case $SORT in
10944 10944 [\\/]* | ?:[\\/]*)
10945 10945 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10946 10946 ;;
10947 10947 *)
10948 10948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10949 10949 for as_dir in $PATH
10950 10950 do
10951 10951 IFS=$as_save_IFS
10952 10952 test -z "$as_dir" && as_dir=.
10953 10953 for ac_exec_ext in '' $ac_executable_extensions; do
10954 10954 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10955 10955 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10956 10956 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10957 10957 break 2
10958 10958 fi
10959 10959 done
10960 10960 done
10961 10961 IFS=$as_save_IFS
10962 10962
10963 10963 ;;
10964 10964 esac
10965 10965 fi
10966 10966 SORT=$ac_cv_path_SORT
10967 10967 if test -n "$SORT"; then
10968 10968 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10969 10969 $as_echo "$SORT" >&6; }
10970 10970 else
10971 10971 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10972 10972 $as_echo "no" >&6; }
10973 10973 fi
10974 10974
10975 10975
10976 10976 test -n "$SORT" && break
10977 10977 done
10978 10978
10979 10979 else
10980 10980 # If it succeeded, then it was overridden by the user. We will use it
10981 10981 # for the tool.
10982 10982
10983 10983 # First remove it from the list of overridden variables, so we can test
10984 10984 # for unknown variables in the end.
10985 10985 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10986 10986
10987 10987 # Check if we try to supply an empty value
10988 10988 if test "x$SORT" = x; then
10989 10989 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10990 10990 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10991 10991 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10992 10992 $as_echo_n "checking for SORT... " >&6; }
10993 10993 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10994 10994 $as_echo "disabled" >&6; }
10995 10995 else
10996 10996 # Check if the provided tool contains a complete path.
10997 10997 tool_specified="$SORT"
10998 10998 tool_basename="${tool_specified##*/}"
10999 10999 if test "x$tool_basename" = "x$tool_specified"; then
11000 11000 # A command without a complete path is provided, search $PATH.
11001 11001 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
11002 11002 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
11003 11003 # Extract the first word of "$tool_basename", so it can be a program name with args.
11004 11004 set dummy $tool_basename; ac_word=$2
11005 11005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11006 11006 $as_echo_n "checking for $ac_word... " >&6; }
11007 11007 if ${ac_cv_path_SORT+:} false; then :
11008 11008 $as_echo_n "(cached) " >&6
11009 11009 else
11010 11010 case $SORT in
11011 11011 [\\/]* | ?:[\\/]*)
11012 11012 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
11013 11013 ;;
11014 11014 *)
11015 11015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11016 11016 for as_dir in $PATH
11017 11017 do
11018 11018 IFS=$as_save_IFS
11019 11019 test -z "$as_dir" && as_dir=.
11020 11020 for ac_exec_ext in '' $ac_executable_extensions; do
11021 11021 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11022 11022 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
11023 11023 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11024 11024 break 2
11025 11025 fi
11026 11026 done
11027 11027 done
11028 11028 IFS=$as_save_IFS
11029 11029
11030 11030 ;;
11031 11031 esac
11032 11032 fi
11033 11033 SORT=$ac_cv_path_SORT
11034 11034 if test -n "$SORT"; then
11035 11035 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
11036 11036 $as_echo "$SORT" >&6; }
11037 11037 else
11038 11038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11039 11039 $as_echo "no" >&6; }
11040 11040 fi
11041 11041
11042 11042
11043 11043 if test "x$SORT" = x; then
11044 11044 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11045 11045 fi
11046 11046 else
11047 11047 # Otherwise we believe it is a complete path. Use it as it is.
11048 11048 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
11049 11049 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
11050 11050 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
11051 11051 $as_echo_n "checking for SORT... " >&6; }
11052 11052 if test ! -x "$tool_specified"; then
11053 11053 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11054 11054 $as_echo "not found" >&6; }
11055 11055 as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
11056 11056 fi
11057 11057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11058 11058 $as_echo "$tool_specified" >&6; }
11059 11059 fi
11060 11060 fi
11061 11061 fi
11062 11062
11063 11063 fi
11064 11064
11065 11065
11066 11066
11067 11067 if test "x$SORT" = x; then
11068 11068 as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
11069 11069 fi
11070 11070
11071 11071
11072 11072
11073 11073
11074 11074
11075 11075 # Publish this variable in the help.
11076 11076
11077 11077
11078 11078 if [ -z "${TAIL+x}" ]; then
11079 11079 # The variable is not set by user, try to locate tool using the code snippet
11080 11080 for ac_prog in tail
11081 11081 do
11082 11082 # Extract the first word of "$ac_prog", so it can be a program name with args.
11083 11083 set dummy $ac_prog; ac_word=$2
11084 11084 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11085 11085 $as_echo_n "checking for $ac_word... " >&6; }
11086 11086 if ${ac_cv_path_TAIL+:} false; then :
11087 11087 $as_echo_n "(cached) " >&6
11088 11088 else
11089 11089 case $TAIL in
11090 11090 [\\/]* | ?:[\\/]*)
11091 11091 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11092 11092 ;;
11093 11093 *)
11094 11094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11095 11095 for as_dir in $PATH
11096 11096 do
11097 11097 IFS=$as_save_IFS
11098 11098 test -z "$as_dir" && as_dir=.
11099 11099 for ac_exec_ext in '' $ac_executable_extensions; do
11100 11100 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11101 11101 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11102 11102 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11103 11103 break 2
11104 11104 fi
11105 11105 done
11106 11106 done
11107 11107 IFS=$as_save_IFS
11108 11108
11109 11109 ;;
11110 11110 esac
11111 11111 fi
11112 11112 TAIL=$ac_cv_path_TAIL
11113 11113 if test -n "$TAIL"; then
11114 11114 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11115 11115 $as_echo "$TAIL" >&6; }
11116 11116 else
11117 11117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11118 11118 $as_echo "no" >&6; }
11119 11119 fi
11120 11120
11121 11121
11122 11122 test -n "$TAIL" && break
11123 11123 done
11124 11124
11125 11125 else
11126 11126 # The variable is set, but is it from the command line or the environment?
11127 11127
11128 11128 # Try to remove the string !TAIL! from our list.
11129 11129 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
11130 11130 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11131 11131 # If it failed, the variable was not from the command line. Ignore it,
11132 11132 # but warn the user (except for BASH, which is always set by the calling BASH).
11133 11133 if test "xTAIL" != xBASH; then
11134 11134 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
11135 11135 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
11136 11136 fi
11137 11137 # Try to locate tool using the code snippet
11138 11138 for ac_prog in tail
11139 11139 do
11140 11140 # Extract the first word of "$ac_prog", so it can be a program name with args.
11141 11141 set dummy $ac_prog; ac_word=$2
11142 11142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11143 11143 $as_echo_n "checking for $ac_word... " >&6; }
11144 11144 if ${ac_cv_path_TAIL+:} false; then :
11145 11145 $as_echo_n "(cached) " >&6
11146 11146 else
11147 11147 case $TAIL in
11148 11148 [\\/]* | ?:[\\/]*)
11149 11149 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11150 11150 ;;
11151 11151 *)
11152 11152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11153 11153 for as_dir in $PATH
11154 11154 do
11155 11155 IFS=$as_save_IFS
11156 11156 test -z "$as_dir" && as_dir=.
11157 11157 for ac_exec_ext in '' $ac_executable_extensions; do
11158 11158 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11159 11159 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11160 11160 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11161 11161 break 2
11162 11162 fi
11163 11163 done
11164 11164 done
11165 11165 IFS=$as_save_IFS
11166 11166
11167 11167 ;;
11168 11168 esac
11169 11169 fi
11170 11170 TAIL=$ac_cv_path_TAIL
11171 11171 if test -n "$TAIL"; then
11172 11172 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11173 11173 $as_echo "$TAIL" >&6; }
11174 11174 else
11175 11175 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11176 11176 $as_echo "no" >&6; }
11177 11177 fi
11178 11178
11179 11179
11180 11180 test -n "$TAIL" && break
11181 11181 done
11182 11182
11183 11183 else
11184 11184 # If it succeeded, then it was overridden by the user. We will use it
11185 11185 # for the tool.
11186 11186
11187 11187 # First remove it from the list of overridden variables, so we can test
11188 11188 # for unknown variables in the end.
11189 11189 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11190 11190
11191 11191 # Check if we try to supply an empty value
11192 11192 if test "x$TAIL" = x; then
11193 11193 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
11194 11194 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
11195 11195 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11196 11196 $as_echo_n "checking for TAIL... " >&6; }
11197 11197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11198 11198 $as_echo "disabled" >&6; }
11199 11199 else
11200 11200 # Check if the provided tool contains a complete path.
11201 11201 tool_specified="$TAIL"
11202 11202 tool_basename="${tool_specified##*/}"
11203 11203 if test "x$tool_basename" = "x$tool_specified"; then
11204 11204 # A command without a complete path is provided, search $PATH.
11205 11205 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
11206 11206 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
11207 11207 # Extract the first word of "$tool_basename", so it can be a program name with args.
11208 11208 set dummy $tool_basename; ac_word=$2
11209 11209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11210 11210 $as_echo_n "checking for $ac_word... " >&6; }
11211 11211 if ${ac_cv_path_TAIL+:} false; then :
11212 11212 $as_echo_n "(cached) " >&6
11213 11213 else
11214 11214 case $TAIL in
11215 11215 [\\/]* | ?:[\\/]*)
11216 11216 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11217 11217 ;;
11218 11218 *)
11219 11219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11220 11220 for as_dir in $PATH
11221 11221 do
11222 11222 IFS=$as_save_IFS
11223 11223 test -z "$as_dir" && as_dir=.
11224 11224 for ac_exec_ext in '' $ac_executable_extensions; do
11225 11225 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11226 11226 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11227 11227 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11228 11228 break 2
11229 11229 fi
11230 11230 done
11231 11231 done
11232 11232 IFS=$as_save_IFS
11233 11233
11234 11234 ;;
11235 11235 esac
11236 11236 fi
11237 11237 TAIL=$ac_cv_path_TAIL
11238 11238 if test -n "$TAIL"; then
11239 11239 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11240 11240 $as_echo "$TAIL" >&6; }
11241 11241 else
11242 11242 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11243 11243 $as_echo "no" >&6; }
11244 11244 fi
11245 11245
11246 11246
11247 11247 if test "x$TAIL" = x; then
11248 11248 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11249 11249 fi
11250 11250 else
11251 11251 # Otherwise we believe it is a complete path. Use it as it is.
11252 11252 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
11253 11253 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
11254 11254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11255 11255 $as_echo_n "checking for TAIL... " >&6; }
11256 11256 if test ! -x "$tool_specified"; then
11257 11257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11258 11258 $as_echo "not found" >&6; }
11259 11259 as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
11260 11260 fi
11261 11261 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11262 11262 $as_echo "$tool_specified" >&6; }
11263 11263 fi
11264 11264 fi
11265 11265 fi
11266 11266
11267 11267 fi
11268 11268
11269 11269
11270 11270
11271 11271 if test "x$TAIL" = x; then
11272 11272 as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
11273 11273 fi
11274 11274
11275 11275
11276 11276
11277 11277
11278 11278
11279 11279 # Publish this variable in the help.
11280 11280
11281 11281
11282 11282 if [ -z "${TAR+x}" ]; then
11283 11283 # The variable is not set by user, try to locate tool using the code snippet
11284 11284 for ac_prog in gtar tar
11285 11285 do
11286 11286 # Extract the first word of "$ac_prog", so it can be a program name with args.
11287 11287 set dummy $ac_prog; ac_word=$2
11288 11288 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11289 11289 $as_echo_n "checking for $ac_word... " >&6; }
11290 11290 if ${ac_cv_path_TAR+:} false; then :
11291 11291 $as_echo_n "(cached) " >&6
11292 11292 else
11293 11293 case $TAR in
11294 11294 [\\/]* | ?:[\\/]*)
11295 11295 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11296 11296 ;;
11297 11297 *)
11298 11298 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11299 11299 for as_dir in $PATH
11300 11300 do
11301 11301 IFS=$as_save_IFS
11302 11302 test -z "$as_dir" && as_dir=.
11303 11303 for ac_exec_ext in '' $ac_executable_extensions; do
11304 11304 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11305 11305 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11306 11306 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11307 11307 break 2
11308 11308 fi
11309 11309 done
11310 11310 done
11311 11311 IFS=$as_save_IFS
11312 11312
11313 11313 ;;
11314 11314 esac
11315 11315 fi
11316 11316 TAR=$ac_cv_path_TAR
11317 11317 if test -n "$TAR"; then
11318 11318 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11319 11319 $as_echo "$TAR" >&6; }
11320 11320 else
11321 11321 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11322 11322 $as_echo "no" >&6; }
11323 11323 fi
11324 11324
11325 11325
11326 11326 test -n "$TAR" && break
11327 11327 done
11328 11328
11329 11329 else
11330 11330 # The variable is set, but is it from the command line or the environment?
11331 11331
11332 11332 # Try to remove the string !TAR! from our list.
11333 11333 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
11334 11334 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11335 11335 # If it failed, the variable was not from the command line. Ignore it,
11336 11336 # but warn the user (except for BASH, which is always set by the calling BASH).
11337 11337 if test "xTAR" != xBASH; then
11338 11338 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
11339 11339 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
11340 11340 fi
11341 11341 # Try to locate tool using the code snippet
11342 11342 for ac_prog in gtar tar
11343 11343 do
11344 11344 # Extract the first word of "$ac_prog", so it can be a program name with args.
11345 11345 set dummy $ac_prog; ac_word=$2
11346 11346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11347 11347 $as_echo_n "checking for $ac_word... " >&6; }
11348 11348 if ${ac_cv_path_TAR+:} false; then :
11349 11349 $as_echo_n "(cached) " >&6
11350 11350 else
11351 11351 case $TAR in
11352 11352 [\\/]* | ?:[\\/]*)
11353 11353 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11354 11354 ;;
11355 11355 *)
11356 11356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11357 11357 for as_dir in $PATH
11358 11358 do
11359 11359 IFS=$as_save_IFS
11360 11360 test -z "$as_dir" && as_dir=.
11361 11361 for ac_exec_ext in '' $ac_executable_extensions; do
11362 11362 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11363 11363 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11364 11364 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11365 11365 break 2
11366 11366 fi
11367 11367 done
11368 11368 done
11369 11369 IFS=$as_save_IFS
11370 11370
11371 11371 ;;
11372 11372 esac
11373 11373 fi
11374 11374 TAR=$ac_cv_path_TAR
11375 11375 if test -n "$TAR"; then
11376 11376 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11377 11377 $as_echo "$TAR" >&6; }
11378 11378 else
11379 11379 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11380 11380 $as_echo "no" >&6; }
11381 11381 fi
11382 11382
11383 11383
11384 11384 test -n "$TAR" && break
11385 11385 done
11386 11386
11387 11387 else
11388 11388 # If it succeeded, then it was overridden by the user. We will use it
11389 11389 # for the tool.
11390 11390
11391 11391 # First remove it from the list of overridden variables, so we can test
11392 11392 # for unknown variables in the end.
11393 11393 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11394 11394
11395 11395 # Check if we try to supply an empty value
11396 11396 if test "x$TAR" = x; then
11397 11397 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
11398 11398 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
11399 11399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11400 11400 $as_echo_n "checking for TAR... " >&6; }
11401 11401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11402 11402 $as_echo "disabled" >&6; }
11403 11403 else
11404 11404 # Check if the provided tool contains a complete path.
11405 11405 tool_specified="$TAR"
11406 11406 tool_basename="${tool_specified##*/}"
11407 11407 if test "x$tool_basename" = "x$tool_specified"; then
11408 11408 # A command without a complete path is provided, search $PATH.
11409 11409 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
11410 11410 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
11411 11411 # Extract the first word of "$tool_basename", so it can be a program name with args.
11412 11412 set dummy $tool_basename; ac_word=$2
11413 11413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11414 11414 $as_echo_n "checking for $ac_word... " >&6; }
11415 11415 if ${ac_cv_path_TAR+:} false; then :
11416 11416 $as_echo_n "(cached) " >&6
11417 11417 else
11418 11418 case $TAR in
11419 11419 [\\/]* | ?:[\\/]*)
11420 11420 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11421 11421 ;;
11422 11422 *)
11423 11423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11424 11424 for as_dir in $PATH
11425 11425 do
11426 11426 IFS=$as_save_IFS
11427 11427 test -z "$as_dir" && as_dir=.
11428 11428 for ac_exec_ext in '' $ac_executable_extensions; do
11429 11429 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11430 11430 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11431 11431 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11432 11432 break 2
11433 11433 fi
11434 11434 done
11435 11435 done
11436 11436 IFS=$as_save_IFS
11437 11437
11438 11438 ;;
11439 11439 esac
11440 11440 fi
11441 11441 TAR=$ac_cv_path_TAR
11442 11442 if test -n "$TAR"; then
11443 11443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11444 11444 $as_echo "$TAR" >&6; }
11445 11445 else
11446 11446 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11447 11447 $as_echo "no" >&6; }
11448 11448 fi
11449 11449
11450 11450
11451 11451 if test "x$TAR" = x; then
11452 11452 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11453 11453 fi
11454 11454 else
11455 11455 # Otherwise we believe it is a complete path. Use it as it is.
11456 11456 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
11457 11457 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
11458 11458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11459 11459 $as_echo_n "checking for TAR... " >&6; }
11460 11460 if test ! -x "$tool_specified"; then
11461 11461 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11462 11462 $as_echo "not found" >&6; }
11463 11463 as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
11464 11464 fi
11465 11465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11466 11466 $as_echo "$tool_specified" >&6; }
11467 11467 fi
11468 11468 fi
11469 11469 fi
11470 11470
11471 11471 fi
11472 11472
11473 11473
11474 11474
11475 11475 if test "x$TAR" = x; then
11476 11476 as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
11477 11477 fi
11478 11478
11479 11479
11480 11480
11481 11481
11482 11482
11483 11483 # Publish this variable in the help.
11484 11484
11485 11485
11486 11486 if [ -z "${TEE+x}" ]; then
11487 11487 # The variable is not set by user, try to locate tool using the code snippet
11488 11488 for ac_prog in tee
11489 11489 do
11490 11490 # Extract the first word of "$ac_prog", so it can be a program name with args.
11491 11491 set dummy $ac_prog; ac_word=$2
11492 11492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11493 11493 $as_echo_n "checking for $ac_word... " >&6; }
11494 11494 if ${ac_cv_path_TEE+:} false; then :
11495 11495 $as_echo_n "(cached) " >&6
11496 11496 else
11497 11497 case $TEE in
11498 11498 [\\/]* | ?:[\\/]*)
11499 11499 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11500 11500 ;;
11501 11501 *)
11502 11502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11503 11503 for as_dir in $PATH
11504 11504 do
11505 11505 IFS=$as_save_IFS
11506 11506 test -z "$as_dir" && as_dir=.
11507 11507 for ac_exec_ext in '' $ac_executable_extensions; do
11508 11508 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11509 11509 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11510 11510 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11511 11511 break 2
11512 11512 fi
11513 11513 done
11514 11514 done
11515 11515 IFS=$as_save_IFS
11516 11516
11517 11517 ;;
11518 11518 esac
11519 11519 fi
11520 11520 TEE=$ac_cv_path_TEE
11521 11521 if test -n "$TEE"; then
11522 11522 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11523 11523 $as_echo "$TEE" >&6; }
11524 11524 else
11525 11525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11526 11526 $as_echo "no" >&6; }
11527 11527 fi
11528 11528
11529 11529
11530 11530 test -n "$TEE" && break
11531 11531 done
11532 11532
11533 11533 else
11534 11534 # The variable is set, but is it from the command line or the environment?
11535 11535
11536 11536 # Try to remove the string !TEE! from our list.
11537 11537 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
11538 11538 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11539 11539 # If it failed, the variable was not from the command line. Ignore it,
11540 11540 # but warn the user (except for BASH, which is always set by the calling BASH).
11541 11541 if test "xTEE" != xBASH; then
11542 11542 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
11543 11543 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
11544 11544 fi
11545 11545 # Try to locate tool using the code snippet
11546 11546 for ac_prog in tee
11547 11547 do
11548 11548 # Extract the first word of "$ac_prog", so it can be a program name with args.
11549 11549 set dummy $ac_prog; ac_word=$2
11550 11550 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11551 11551 $as_echo_n "checking for $ac_word... " >&6; }
11552 11552 if ${ac_cv_path_TEE+:} false; then :
11553 11553 $as_echo_n "(cached) " >&6
11554 11554 else
11555 11555 case $TEE in
11556 11556 [\\/]* | ?:[\\/]*)
11557 11557 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11558 11558 ;;
11559 11559 *)
11560 11560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11561 11561 for as_dir in $PATH
11562 11562 do
11563 11563 IFS=$as_save_IFS
11564 11564 test -z "$as_dir" && as_dir=.
11565 11565 for ac_exec_ext in '' $ac_executable_extensions; do
11566 11566 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11567 11567 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11568 11568 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11569 11569 break 2
11570 11570 fi
11571 11571 done
11572 11572 done
11573 11573 IFS=$as_save_IFS
11574 11574
11575 11575 ;;
11576 11576 esac
11577 11577 fi
11578 11578 TEE=$ac_cv_path_TEE
11579 11579 if test -n "$TEE"; then
11580 11580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11581 11581 $as_echo "$TEE" >&6; }
11582 11582 else
11583 11583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11584 11584 $as_echo "no" >&6; }
11585 11585 fi
11586 11586
11587 11587
11588 11588 test -n "$TEE" && break
11589 11589 done
11590 11590
11591 11591 else
11592 11592 # If it succeeded, then it was overridden by the user. We will use it
11593 11593 # for the tool.
11594 11594
11595 11595 # First remove it from the list of overridden variables, so we can test
11596 11596 # for unknown variables in the end.
11597 11597 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11598 11598
11599 11599 # Check if we try to supply an empty value
11600 11600 if test "x$TEE" = x; then
11601 11601 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
11602 11602 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
11603 11603 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11604 11604 $as_echo_n "checking for TEE... " >&6; }
11605 11605 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11606 11606 $as_echo "disabled" >&6; }
11607 11607 else
11608 11608 # Check if the provided tool contains a complete path.
11609 11609 tool_specified="$TEE"
11610 11610 tool_basename="${tool_specified##*/}"
11611 11611 if test "x$tool_basename" = "x$tool_specified"; then
11612 11612 # A command without a complete path is provided, search $PATH.
11613 11613 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
11614 11614 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
11615 11615 # Extract the first word of "$tool_basename", so it can be a program name with args.
11616 11616 set dummy $tool_basename; ac_word=$2
11617 11617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11618 11618 $as_echo_n "checking for $ac_word... " >&6; }
11619 11619 if ${ac_cv_path_TEE+:} false; then :
11620 11620 $as_echo_n "(cached) " >&6
11621 11621 else
11622 11622 case $TEE in
11623 11623 [\\/]* | ?:[\\/]*)
11624 11624 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11625 11625 ;;
11626 11626 *)
11627 11627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11628 11628 for as_dir in $PATH
11629 11629 do
11630 11630 IFS=$as_save_IFS
11631 11631 test -z "$as_dir" && as_dir=.
11632 11632 for ac_exec_ext in '' $ac_executable_extensions; do
11633 11633 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11634 11634 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11635 11635 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11636 11636 break 2
11637 11637 fi
11638 11638 done
11639 11639 done
11640 11640 IFS=$as_save_IFS
11641 11641
11642 11642 ;;
11643 11643 esac
11644 11644 fi
11645 11645 TEE=$ac_cv_path_TEE
11646 11646 if test -n "$TEE"; then
11647 11647 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11648 11648 $as_echo "$TEE" >&6; }
11649 11649 else
11650 11650 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11651 11651 $as_echo "no" >&6; }
11652 11652 fi
11653 11653
11654 11654
11655 11655 if test "x$TEE" = x; then
11656 11656 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11657 11657 fi
11658 11658 else
11659 11659 # Otherwise we believe it is a complete path. Use it as it is.
11660 11660 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
11661 11661 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
11662 11662 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11663 11663 $as_echo_n "checking for TEE... " >&6; }
11664 11664 if test ! -x "$tool_specified"; then
11665 11665 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11666 11666 $as_echo "not found" >&6; }
11667 11667 as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
11668 11668 fi
11669 11669 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11670 11670 $as_echo "$tool_specified" >&6; }
11671 11671 fi
11672 11672 fi
11673 11673 fi
11674 11674
11675 11675 fi
11676 11676
11677 11677
11678 11678
11679 11679 if test "x$TEE" = x; then
11680 11680 as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
11681 11681 fi
11682 11682
11683 11683
11684 11684
11685 11685
11686 11686
11687 11687 # Publish this variable in the help.
11688 11688
11689 11689
11690 11690 if [ -z "${TOUCH+x}" ]; then
11691 11691 # The variable is not set by user, try to locate tool using the code snippet
11692 11692 for ac_prog in touch
11693 11693 do
11694 11694 # Extract the first word of "$ac_prog", so it can be a program name with args.
11695 11695 set dummy $ac_prog; ac_word=$2
11696 11696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11697 11697 $as_echo_n "checking for $ac_word... " >&6; }
11698 11698 if ${ac_cv_path_TOUCH+:} false; then :
11699 11699 $as_echo_n "(cached) " >&6
11700 11700 else
11701 11701 case $TOUCH in
11702 11702 [\\/]* | ?:[\\/]*)
11703 11703 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11704 11704 ;;
11705 11705 *)
11706 11706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11707 11707 for as_dir in $PATH
11708 11708 do
11709 11709 IFS=$as_save_IFS
11710 11710 test -z "$as_dir" && as_dir=.
11711 11711 for ac_exec_ext in '' $ac_executable_extensions; do
11712 11712 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11713 11713 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11714 11714 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11715 11715 break 2
11716 11716 fi
11717 11717 done
11718 11718 done
11719 11719 IFS=$as_save_IFS
11720 11720
11721 11721 ;;
11722 11722 esac
11723 11723 fi
11724 11724 TOUCH=$ac_cv_path_TOUCH
11725 11725 if test -n "$TOUCH"; then
11726 11726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11727 11727 $as_echo "$TOUCH" >&6; }
11728 11728 else
11729 11729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11730 11730 $as_echo "no" >&6; }
11731 11731 fi
11732 11732
11733 11733
11734 11734 test -n "$TOUCH" && break
11735 11735 done
11736 11736
11737 11737 else
11738 11738 # The variable is set, but is it from the command line or the environment?
11739 11739
11740 11740 # Try to remove the string !TOUCH! from our list.
11741 11741 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
11742 11742 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11743 11743 # If it failed, the variable was not from the command line. Ignore it,
11744 11744 # but warn the user (except for BASH, which is always set by the calling BASH).
11745 11745 if test "xTOUCH" != xBASH; then
11746 11746 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
11747 11747 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
11748 11748 fi
11749 11749 # Try to locate tool using the code snippet
11750 11750 for ac_prog in touch
11751 11751 do
11752 11752 # Extract the first word of "$ac_prog", so it can be a program name with args.
11753 11753 set dummy $ac_prog; ac_word=$2
11754 11754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11755 11755 $as_echo_n "checking for $ac_word... " >&6; }
11756 11756 if ${ac_cv_path_TOUCH+:} false; then :
11757 11757 $as_echo_n "(cached) " >&6
11758 11758 else
11759 11759 case $TOUCH in
11760 11760 [\\/]* | ?:[\\/]*)
11761 11761 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11762 11762 ;;
11763 11763 *)
11764 11764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11765 11765 for as_dir in $PATH
11766 11766 do
11767 11767 IFS=$as_save_IFS
11768 11768 test -z "$as_dir" && as_dir=.
11769 11769 for ac_exec_ext in '' $ac_executable_extensions; do
11770 11770 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11771 11771 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11772 11772 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11773 11773 break 2
11774 11774 fi
11775 11775 done
11776 11776 done
11777 11777 IFS=$as_save_IFS
11778 11778
11779 11779 ;;
11780 11780 esac
11781 11781 fi
11782 11782 TOUCH=$ac_cv_path_TOUCH
11783 11783 if test -n "$TOUCH"; then
11784 11784 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11785 11785 $as_echo "$TOUCH" >&6; }
11786 11786 else
11787 11787 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11788 11788 $as_echo "no" >&6; }
11789 11789 fi
11790 11790
11791 11791
11792 11792 test -n "$TOUCH" && break
11793 11793 done
11794 11794
11795 11795 else
11796 11796 # If it succeeded, then it was overridden by the user. We will use it
11797 11797 # for the tool.
11798 11798
11799 11799 # First remove it from the list of overridden variables, so we can test
11800 11800 # for unknown variables in the end.
11801 11801 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11802 11802
11803 11803 # Check if we try to supply an empty value
11804 11804 if test "x$TOUCH" = x; then
11805 11805 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11806 11806 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11807 11807 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11808 11808 $as_echo_n "checking for TOUCH... " >&6; }
11809 11809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11810 11810 $as_echo "disabled" >&6; }
11811 11811 else
11812 11812 # Check if the provided tool contains a complete path.
11813 11813 tool_specified="$TOUCH"
11814 11814 tool_basename="${tool_specified##*/}"
11815 11815 if test "x$tool_basename" = "x$tool_specified"; then
11816 11816 # A command without a complete path is provided, search $PATH.
11817 11817 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11818 11818 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11819 11819 # Extract the first word of "$tool_basename", so it can be a program name with args.
11820 11820 set dummy $tool_basename; ac_word=$2
11821 11821 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11822 11822 $as_echo_n "checking for $ac_word... " >&6; }
11823 11823 if ${ac_cv_path_TOUCH+:} false; then :
11824 11824 $as_echo_n "(cached) " >&6
11825 11825 else
11826 11826 case $TOUCH in
11827 11827 [\\/]* | ?:[\\/]*)
11828 11828 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11829 11829 ;;
11830 11830 *)
11831 11831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11832 11832 for as_dir in $PATH
11833 11833 do
11834 11834 IFS=$as_save_IFS
11835 11835 test -z "$as_dir" && as_dir=.
11836 11836 for ac_exec_ext in '' $ac_executable_extensions; do
11837 11837 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11838 11838 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11839 11839 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11840 11840 break 2
11841 11841 fi
11842 11842 done
11843 11843 done
11844 11844 IFS=$as_save_IFS
11845 11845
11846 11846 ;;
11847 11847 esac
11848 11848 fi
11849 11849 TOUCH=$ac_cv_path_TOUCH
11850 11850 if test -n "$TOUCH"; then
11851 11851 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11852 11852 $as_echo "$TOUCH" >&6; }
11853 11853 else
11854 11854 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11855 11855 $as_echo "no" >&6; }
11856 11856 fi
11857 11857
11858 11858
11859 11859 if test "x$TOUCH" = x; then
11860 11860 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11861 11861 fi
11862 11862 else
11863 11863 # Otherwise we believe it is a complete path. Use it as it is.
11864 11864 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11865 11865 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11866 11866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11867 11867 $as_echo_n "checking for TOUCH... " >&6; }
11868 11868 if test ! -x "$tool_specified"; then
11869 11869 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11870 11870 $as_echo "not found" >&6; }
11871 11871 as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11872 11872 fi
11873 11873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11874 11874 $as_echo "$tool_specified" >&6; }
11875 11875 fi
11876 11876 fi
11877 11877 fi
11878 11878
11879 11879 fi
11880 11880
11881 11881
11882 11882
11883 11883 if test "x$TOUCH" = x; then
11884 11884 as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11885 11885 fi
11886 11886
11887 11887
11888 11888
11889 11889
11890 11890
11891 11891 # Publish this variable in the help.
11892 11892
11893 11893
11894 11894 if [ -z "${TR+x}" ]; then
11895 11895 # The variable is not set by user, try to locate tool using the code snippet
11896 11896 for ac_prog in tr
11897 11897 do
11898 11898 # Extract the first word of "$ac_prog", so it can be a program name with args.
11899 11899 set dummy $ac_prog; ac_word=$2
11900 11900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11901 11901 $as_echo_n "checking for $ac_word... " >&6; }
11902 11902 if ${ac_cv_path_TR+:} false; then :
11903 11903 $as_echo_n "(cached) " >&6
11904 11904 else
11905 11905 case $TR in
11906 11906 [\\/]* | ?:[\\/]*)
11907 11907 ac_cv_path_TR="$TR" # Let the user override the test with a path.
11908 11908 ;;
11909 11909 *)
11910 11910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11911 11911 for as_dir in $PATH
11912 11912 do
11913 11913 IFS=$as_save_IFS
11914 11914 test -z "$as_dir" && as_dir=.
11915 11915 for ac_exec_ext in '' $ac_executable_extensions; do
11916 11916 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11917 11917 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11918 11918 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11919 11919 break 2
11920 11920 fi
11921 11921 done
11922 11922 done
11923 11923 IFS=$as_save_IFS
11924 11924
11925 11925 ;;
11926 11926 esac
11927 11927 fi
11928 11928 TR=$ac_cv_path_TR
11929 11929 if test -n "$TR"; then
11930 11930 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11931 11931 $as_echo "$TR" >&6; }
11932 11932 else
11933 11933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11934 11934 $as_echo "no" >&6; }
11935 11935 fi
11936 11936
11937 11937
11938 11938 test -n "$TR" && break
11939 11939 done
11940 11940
11941 11941 else
11942 11942 # The variable is set, but is it from the command line or the environment?
11943 11943
11944 11944 # Try to remove the string !TR! from our list.
11945 11945 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11946 11946 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11947 11947 # If it failed, the variable was not from the command line. Ignore it,
11948 11948 # but warn the user (except for BASH, which is always set by the calling BASH).
11949 11949 if test "xTR" != xBASH; then
11950 11950 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11951 11951 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11952 11952 fi
11953 11953 # Try to locate tool using the code snippet
11954 11954 for ac_prog in tr
11955 11955 do
11956 11956 # Extract the first word of "$ac_prog", so it can be a program name with args.
11957 11957 set dummy $ac_prog; ac_word=$2
11958 11958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11959 11959 $as_echo_n "checking for $ac_word... " >&6; }
11960 11960 if ${ac_cv_path_TR+:} false; then :
11961 11961 $as_echo_n "(cached) " >&6
11962 11962 else
11963 11963 case $TR in
11964 11964 [\\/]* | ?:[\\/]*)
11965 11965 ac_cv_path_TR="$TR" # Let the user override the test with a path.
11966 11966 ;;
11967 11967 *)
11968 11968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11969 11969 for as_dir in $PATH
11970 11970 do
11971 11971 IFS=$as_save_IFS
11972 11972 test -z "$as_dir" && as_dir=.
11973 11973 for ac_exec_ext in '' $ac_executable_extensions; do
11974 11974 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11975 11975 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11976 11976 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11977 11977 break 2
11978 11978 fi
11979 11979 done
11980 11980 done
11981 11981 IFS=$as_save_IFS
11982 11982
11983 11983 ;;
11984 11984 esac
11985 11985 fi
11986 11986 TR=$ac_cv_path_TR
11987 11987 if test -n "$TR"; then
11988 11988 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11989 11989 $as_echo "$TR" >&6; }
11990 11990 else
11991 11991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11992 11992 $as_echo "no" >&6; }
11993 11993 fi
11994 11994
11995 11995
11996 11996 test -n "$TR" && break
11997 11997 done
11998 11998
11999 11999 else
12000 12000 # If it succeeded, then it was overridden by the user. We will use it
12001 12001 # for the tool.
12002 12002
12003 12003 # First remove it from the list of overridden variables, so we can test
12004 12004 # for unknown variables in the end.
12005 12005 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12006 12006
12007 12007 # Check if we try to supply an empty value
12008 12008 if test "x$TR" = x; then
12009 12009 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
12010 12010 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
12011 12011 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12012 12012 $as_echo_n "checking for TR... " >&6; }
12013 12013 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12014 12014 $as_echo "disabled" >&6; }
12015 12015 else
12016 12016 # Check if the provided tool contains a complete path.
12017 12017 tool_specified="$TR"
12018 12018 tool_basename="${tool_specified##*/}"
12019 12019 if test "x$tool_basename" = "x$tool_specified"; then
12020 12020 # A command without a complete path is provided, search $PATH.
12021 12021 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
12022 12022 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
12023 12023 # Extract the first word of "$tool_basename", so it can be a program name with args.
12024 12024 set dummy $tool_basename; ac_word=$2
12025 12025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12026 12026 $as_echo_n "checking for $ac_word... " >&6; }
12027 12027 if ${ac_cv_path_TR+:} false; then :
12028 12028 $as_echo_n "(cached) " >&6
12029 12029 else
12030 12030 case $TR in
12031 12031 [\\/]* | ?:[\\/]*)
12032 12032 ac_cv_path_TR="$TR" # Let the user override the test with a path.
12033 12033 ;;
12034 12034 *)
12035 12035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12036 12036 for as_dir in $PATH
12037 12037 do
12038 12038 IFS=$as_save_IFS
12039 12039 test -z "$as_dir" && as_dir=.
12040 12040 for ac_exec_ext in '' $ac_executable_extensions; do
12041 12041 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12042 12042 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
12043 12043 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12044 12044 break 2
12045 12045 fi
12046 12046 done
12047 12047 done
12048 12048 IFS=$as_save_IFS
12049 12049
12050 12050 ;;
12051 12051 esac
12052 12052 fi
12053 12053 TR=$ac_cv_path_TR
12054 12054 if test -n "$TR"; then
12055 12055 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
12056 12056 $as_echo "$TR" >&6; }
12057 12057 else
12058 12058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12059 12059 $as_echo "no" >&6; }
12060 12060 fi
12061 12061
12062 12062
12063 12063 if test "x$TR" = x; then
12064 12064 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12065 12065 fi
12066 12066 else
12067 12067 # Otherwise we believe it is a complete path. Use it as it is.
12068 12068 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
12069 12069 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
12070 12070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12071 12071 $as_echo_n "checking for TR... " >&6; }
12072 12072 if test ! -x "$tool_specified"; then
12073 12073 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12074 12074 $as_echo "not found" >&6; }
12075 12075 as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
12076 12076 fi
12077 12077 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12078 12078 $as_echo "$tool_specified" >&6; }
12079 12079 fi
12080 12080 fi
12081 12081 fi
12082 12082
12083 12083 fi
12084 12084
12085 12085
12086 12086
12087 12087 if test "x$TR" = x; then
12088 12088 as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
12089 12089 fi
12090 12090
12091 12091
12092 12092
12093 12093
12094 12094
12095 12095 # Publish this variable in the help.
12096 12096
12097 12097
12098 12098 if [ -z "${UNAME+x}" ]; then
12099 12099 # The variable is not set by user, try to locate tool using the code snippet
12100 12100 for ac_prog in uname
12101 12101 do
12102 12102 # Extract the first word of "$ac_prog", so it can be a program name with args.
12103 12103 set dummy $ac_prog; ac_word=$2
12104 12104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12105 12105 $as_echo_n "checking for $ac_word... " >&6; }
12106 12106 if ${ac_cv_path_UNAME+:} false; then :
12107 12107 $as_echo_n "(cached) " >&6
12108 12108 else
12109 12109 case $UNAME in
12110 12110 [\\/]* | ?:[\\/]*)
12111 12111 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12112 12112 ;;
12113 12113 *)
12114 12114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12115 12115 for as_dir in $PATH
12116 12116 do
12117 12117 IFS=$as_save_IFS
12118 12118 test -z "$as_dir" && as_dir=.
12119 12119 for ac_exec_ext in '' $ac_executable_extensions; do
12120 12120 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12121 12121 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12122 12122 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12123 12123 break 2
12124 12124 fi
12125 12125 done
12126 12126 done
12127 12127 IFS=$as_save_IFS
12128 12128
12129 12129 ;;
12130 12130 esac
12131 12131 fi
12132 12132 UNAME=$ac_cv_path_UNAME
12133 12133 if test -n "$UNAME"; then
12134 12134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12135 12135 $as_echo "$UNAME" >&6; }
12136 12136 else
12137 12137 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12138 12138 $as_echo "no" >&6; }
12139 12139 fi
12140 12140
12141 12141
12142 12142 test -n "$UNAME" && break
12143 12143 done
12144 12144
12145 12145 else
12146 12146 # The variable is set, but is it from the command line or the environment?
12147 12147
12148 12148 # Try to remove the string !UNAME! from our list.
12149 12149 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
12150 12150 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12151 12151 # If it failed, the variable was not from the command line. Ignore it,
12152 12152 # but warn the user (except for BASH, which is always set by the calling BASH).
12153 12153 if test "xUNAME" != xBASH; then
12154 12154 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
12155 12155 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
12156 12156 fi
12157 12157 # Try to locate tool using the code snippet
12158 12158 for ac_prog in uname
12159 12159 do
12160 12160 # Extract the first word of "$ac_prog", so it can be a program name with args.
12161 12161 set dummy $ac_prog; ac_word=$2
12162 12162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12163 12163 $as_echo_n "checking for $ac_word... " >&6; }
12164 12164 if ${ac_cv_path_UNAME+:} false; then :
12165 12165 $as_echo_n "(cached) " >&6
12166 12166 else
12167 12167 case $UNAME in
12168 12168 [\\/]* | ?:[\\/]*)
12169 12169 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12170 12170 ;;
12171 12171 *)
12172 12172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12173 12173 for as_dir in $PATH
12174 12174 do
12175 12175 IFS=$as_save_IFS
12176 12176 test -z "$as_dir" && as_dir=.
12177 12177 for ac_exec_ext in '' $ac_executable_extensions; do
12178 12178 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12179 12179 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12180 12180 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12181 12181 break 2
12182 12182 fi
12183 12183 done
12184 12184 done
12185 12185 IFS=$as_save_IFS
12186 12186
12187 12187 ;;
12188 12188 esac
12189 12189 fi
12190 12190 UNAME=$ac_cv_path_UNAME
12191 12191 if test -n "$UNAME"; then
12192 12192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12193 12193 $as_echo "$UNAME" >&6; }
12194 12194 else
12195 12195 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12196 12196 $as_echo "no" >&6; }
12197 12197 fi
12198 12198
12199 12199
12200 12200 test -n "$UNAME" && break
12201 12201 done
12202 12202
12203 12203 else
12204 12204 # If it succeeded, then it was overridden by the user. We will use it
12205 12205 # for the tool.
12206 12206
12207 12207 # First remove it from the list of overridden variables, so we can test
12208 12208 # for unknown variables in the end.
12209 12209 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12210 12210
12211 12211 # Check if we try to supply an empty value
12212 12212 if test "x$UNAME" = x; then
12213 12213 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
12214 12214 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
12215 12215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12216 12216 $as_echo_n "checking for UNAME... " >&6; }
12217 12217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12218 12218 $as_echo "disabled" >&6; }
12219 12219 else
12220 12220 # Check if the provided tool contains a complete path.
12221 12221 tool_specified="$UNAME"
12222 12222 tool_basename="${tool_specified##*/}"
12223 12223 if test "x$tool_basename" = "x$tool_specified"; then
12224 12224 # A command without a complete path is provided, search $PATH.
12225 12225 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
12226 12226 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
12227 12227 # Extract the first word of "$tool_basename", so it can be a program name with args.
12228 12228 set dummy $tool_basename; ac_word=$2
12229 12229 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12230 12230 $as_echo_n "checking for $ac_word... " >&6; }
12231 12231 if ${ac_cv_path_UNAME+:} false; then :
12232 12232 $as_echo_n "(cached) " >&6
12233 12233 else
12234 12234 case $UNAME in
12235 12235 [\\/]* | ?:[\\/]*)
12236 12236 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12237 12237 ;;
12238 12238 *)
12239 12239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12240 12240 for as_dir in $PATH
12241 12241 do
12242 12242 IFS=$as_save_IFS
12243 12243 test -z "$as_dir" && as_dir=.
12244 12244 for ac_exec_ext in '' $ac_executable_extensions; do
12245 12245 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12246 12246 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12247 12247 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12248 12248 break 2
12249 12249 fi
12250 12250 done
12251 12251 done
12252 12252 IFS=$as_save_IFS
12253 12253
12254 12254 ;;
12255 12255 esac
12256 12256 fi
12257 12257 UNAME=$ac_cv_path_UNAME
12258 12258 if test -n "$UNAME"; then
12259 12259 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12260 12260 $as_echo "$UNAME" >&6; }
12261 12261 else
12262 12262 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12263 12263 $as_echo "no" >&6; }
12264 12264 fi
12265 12265
12266 12266
12267 12267 if test "x$UNAME" = x; then
12268 12268 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12269 12269 fi
12270 12270 else
12271 12271 # Otherwise we believe it is a complete path. Use it as it is.
12272 12272 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
12273 12273 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
12274 12274 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12275 12275 $as_echo_n "checking for UNAME... " >&6; }
12276 12276 if test ! -x "$tool_specified"; then
12277 12277 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12278 12278 $as_echo "not found" >&6; }
12279 12279 as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
12280 12280 fi
12281 12281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12282 12282 $as_echo "$tool_specified" >&6; }
12283 12283 fi
12284 12284 fi
12285 12285 fi
12286 12286
12287 12287 fi
12288 12288
12289 12289
12290 12290
12291 12291 if test "x$UNAME" = x; then
12292 12292 as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
12293 12293 fi
12294 12294
12295 12295
12296 12296
12297 12297
12298 12298
12299 12299 # Publish this variable in the help.
12300 12300
12301 12301
12302 12302 if [ -z "${UNIQ+x}" ]; then
12303 12303 # The variable is not set by user, try to locate tool using the code snippet
12304 12304 for ac_prog in uniq
12305 12305 do
12306 12306 # Extract the first word of "$ac_prog", so it can be a program name with args.
12307 12307 set dummy $ac_prog; ac_word=$2
12308 12308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12309 12309 $as_echo_n "checking for $ac_word... " >&6; }
12310 12310 if ${ac_cv_path_UNIQ+:} false; then :
12311 12311 $as_echo_n "(cached) " >&6
12312 12312 else
12313 12313 case $UNIQ in
12314 12314 [\\/]* | ?:[\\/]*)
12315 12315 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12316 12316 ;;
12317 12317 *)
12318 12318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12319 12319 for as_dir in $PATH
12320 12320 do
12321 12321 IFS=$as_save_IFS
12322 12322 test -z "$as_dir" && as_dir=.
12323 12323 for ac_exec_ext in '' $ac_executable_extensions; do
12324 12324 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12325 12325 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12326 12326 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12327 12327 break 2
12328 12328 fi
12329 12329 done
12330 12330 done
12331 12331 IFS=$as_save_IFS
12332 12332
12333 12333 ;;
12334 12334 esac
12335 12335 fi
12336 12336 UNIQ=$ac_cv_path_UNIQ
12337 12337 if test -n "$UNIQ"; then
12338 12338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12339 12339 $as_echo "$UNIQ" >&6; }
12340 12340 else
12341 12341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12342 12342 $as_echo "no" >&6; }
12343 12343 fi
12344 12344
12345 12345
12346 12346 test -n "$UNIQ" && break
12347 12347 done
12348 12348
12349 12349 else
12350 12350 # The variable is set, but is it from the command line or the environment?
12351 12351
12352 12352 # Try to remove the string !UNIQ! from our list.
12353 12353 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
12354 12354 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12355 12355 # If it failed, the variable was not from the command line. Ignore it,
12356 12356 # but warn the user (except for BASH, which is always set by the calling BASH).
12357 12357 if test "xUNIQ" != xBASH; then
12358 12358 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
12359 12359 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
12360 12360 fi
12361 12361 # Try to locate tool using the code snippet
12362 12362 for ac_prog in uniq
12363 12363 do
12364 12364 # Extract the first word of "$ac_prog", so it can be a program name with args.
12365 12365 set dummy $ac_prog; ac_word=$2
12366 12366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12367 12367 $as_echo_n "checking for $ac_word... " >&6; }
12368 12368 if ${ac_cv_path_UNIQ+:} false; then :
12369 12369 $as_echo_n "(cached) " >&6
12370 12370 else
12371 12371 case $UNIQ in
12372 12372 [\\/]* | ?:[\\/]*)
12373 12373 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12374 12374 ;;
12375 12375 *)
12376 12376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12377 12377 for as_dir in $PATH
12378 12378 do
12379 12379 IFS=$as_save_IFS
12380 12380 test -z "$as_dir" && as_dir=.
12381 12381 for ac_exec_ext in '' $ac_executable_extensions; do
12382 12382 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12383 12383 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12384 12384 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12385 12385 break 2
12386 12386 fi
12387 12387 done
12388 12388 done
12389 12389 IFS=$as_save_IFS
12390 12390
12391 12391 ;;
12392 12392 esac
12393 12393 fi
12394 12394 UNIQ=$ac_cv_path_UNIQ
12395 12395 if test -n "$UNIQ"; then
12396 12396 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12397 12397 $as_echo "$UNIQ" >&6; }
12398 12398 else
12399 12399 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12400 12400 $as_echo "no" >&6; }
12401 12401 fi
12402 12402
12403 12403
12404 12404 test -n "$UNIQ" && break
12405 12405 done
12406 12406
12407 12407 else
12408 12408 # If it succeeded, then it was overridden by the user. We will use it
12409 12409 # for the tool.
12410 12410
12411 12411 # First remove it from the list of overridden variables, so we can test
12412 12412 # for unknown variables in the end.
12413 12413 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12414 12414
12415 12415 # Check if we try to supply an empty value
12416 12416 if test "x$UNIQ" = x; then
12417 12417 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
12418 12418 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
12419 12419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12420 12420 $as_echo_n "checking for UNIQ... " >&6; }
12421 12421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12422 12422 $as_echo "disabled" >&6; }
12423 12423 else
12424 12424 # Check if the provided tool contains a complete path.
12425 12425 tool_specified="$UNIQ"
12426 12426 tool_basename="${tool_specified##*/}"
12427 12427 if test "x$tool_basename" = "x$tool_specified"; then
12428 12428 # A command without a complete path is provided, search $PATH.
12429 12429 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
12430 12430 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
12431 12431 # Extract the first word of "$tool_basename", so it can be a program name with args.
12432 12432 set dummy $tool_basename; ac_word=$2
12433 12433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12434 12434 $as_echo_n "checking for $ac_word... " >&6; }
12435 12435 if ${ac_cv_path_UNIQ+:} false; then :
12436 12436 $as_echo_n "(cached) " >&6
12437 12437 else
12438 12438 case $UNIQ in
12439 12439 [\\/]* | ?:[\\/]*)
12440 12440 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12441 12441 ;;
12442 12442 *)
12443 12443 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12444 12444 for as_dir in $PATH
12445 12445 do
12446 12446 IFS=$as_save_IFS
12447 12447 test -z "$as_dir" && as_dir=.
12448 12448 for ac_exec_ext in '' $ac_executable_extensions; do
12449 12449 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12450 12450 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12451 12451 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12452 12452 break 2
12453 12453 fi
12454 12454 done
12455 12455 done
12456 12456 IFS=$as_save_IFS
12457 12457
12458 12458 ;;
12459 12459 esac
12460 12460 fi
12461 12461 UNIQ=$ac_cv_path_UNIQ
12462 12462 if test -n "$UNIQ"; then
12463 12463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12464 12464 $as_echo "$UNIQ" >&6; }
12465 12465 else
12466 12466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12467 12467 $as_echo "no" >&6; }
12468 12468 fi
12469 12469
12470 12470
12471 12471 if test "x$UNIQ" = x; then
12472 12472 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12473 12473 fi
12474 12474 else
12475 12475 # Otherwise we believe it is a complete path. Use it as it is.
12476 12476 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
12477 12477 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
12478 12478 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12479 12479 $as_echo_n "checking for UNIQ... " >&6; }
12480 12480 if test ! -x "$tool_specified"; then
12481 12481 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12482 12482 $as_echo "not found" >&6; }
12483 12483 as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
12484 12484 fi
12485 12485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12486 12486 $as_echo "$tool_specified" >&6; }
12487 12487 fi
12488 12488 fi
12489 12489 fi
12490 12490
12491 12491 fi
12492 12492
12493 12493
12494 12494
12495 12495 if test "x$UNIQ" = x; then
12496 12496 as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
12497 12497 fi
12498 12498
12499 12499
12500 12500
12501 12501
12502 12502
12503 12503 # Publish this variable in the help.
12504 12504
12505 12505
12506 12506 if [ -z "${WC+x}" ]; then
12507 12507 # The variable is not set by user, try to locate tool using the code snippet
12508 12508 for ac_prog in wc
12509 12509 do
12510 12510 # Extract the first word of "$ac_prog", so it can be a program name with args.
12511 12511 set dummy $ac_prog; ac_word=$2
12512 12512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12513 12513 $as_echo_n "checking for $ac_word... " >&6; }
12514 12514 if ${ac_cv_path_WC+:} false; then :
12515 12515 $as_echo_n "(cached) " >&6
12516 12516 else
12517 12517 case $WC in
12518 12518 [\\/]* | ?:[\\/]*)
12519 12519 ac_cv_path_WC="$WC" # Let the user override the test with a path.
12520 12520 ;;
12521 12521 *)
12522 12522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12523 12523 for as_dir in $PATH
12524 12524 do
12525 12525 IFS=$as_save_IFS
12526 12526 test -z "$as_dir" && as_dir=.
12527 12527 for ac_exec_ext in '' $ac_executable_extensions; do
12528 12528 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12529 12529 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12530 12530 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12531 12531 break 2
12532 12532 fi
12533 12533 done
12534 12534 done
12535 12535 IFS=$as_save_IFS
12536 12536
12537 12537 ;;
12538 12538 esac
12539 12539 fi
12540 12540 WC=$ac_cv_path_WC
12541 12541 if test -n "$WC"; then
12542 12542 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12543 12543 $as_echo "$WC" >&6; }
12544 12544 else
12545 12545 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12546 12546 $as_echo "no" >&6; }
12547 12547 fi
12548 12548
12549 12549
12550 12550 test -n "$WC" && break
12551 12551 done
12552 12552
12553 12553 else
12554 12554 # The variable is set, but is it from the command line or the environment?
12555 12555
12556 12556 # Try to remove the string !WC! from our list.
12557 12557 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
12558 12558 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12559 12559 # If it failed, the variable was not from the command line. Ignore it,
12560 12560 # but warn the user (except for BASH, which is always set by the calling BASH).
12561 12561 if test "xWC" != xBASH; then
12562 12562 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
12563 12563 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
12564 12564 fi
12565 12565 # Try to locate tool using the code snippet
12566 12566 for ac_prog in wc
12567 12567 do
12568 12568 # Extract the first word of "$ac_prog", so it can be a program name with args.
12569 12569 set dummy $ac_prog; ac_word=$2
12570 12570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12571 12571 $as_echo_n "checking for $ac_word... " >&6; }
12572 12572 if ${ac_cv_path_WC+:} false; then :
12573 12573 $as_echo_n "(cached) " >&6
12574 12574 else
12575 12575 case $WC in
12576 12576 [\\/]* | ?:[\\/]*)
12577 12577 ac_cv_path_WC="$WC" # Let the user override the test with a path.
12578 12578 ;;
12579 12579 *)
12580 12580 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12581 12581 for as_dir in $PATH
12582 12582 do
12583 12583 IFS=$as_save_IFS
12584 12584 test -z "$as_dir" && as_dir=.
12585 12585 for ac_exec_ext in '' $ac_executable_extensions; do
12586 12586 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12587 12587 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12588 12588 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12589 12589 break 2
12590 12590 fi
12591 12591 done
12592 12592 done
12593 12593 IFS=$as_save_IFS
12594 12594
12595 12595 ;;
12596 12596 esac
12597 12597 fi
12598 12598 WC=$ac_cv_path_WC
12599 12599 if test -n "$WC"; then
12600 12600 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12601 12601 $as_echo "$WC" >&6; }
12602 12602 else
12603 12603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12604 12604 $as_echo "no" >&6; }
12605 12605 fi
12606 12606
12607 12607
12608 12608 test -n "$WC" && break
12609 12609 done
12610 12610
12611 12611 else
12612 12612 # If it succeeded, then it was overridden by the user. We will use it
12613 12613 # for the tool.
12614 12614
12615 12615 # First remove it from the list of overridden variables, so we can test
12616 12616 # for unknown variables in the end.
12617 12617 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12618 12618
12619 12619 # Check if we try to supply an empty value
12620 12620 if test "x$WC" = x; then
12621 12621 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
12622 12622 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
12623 12623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12624 12624 $as_echo_n "checking for WC... " >&6; }
12625 12625 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12626 12626 $as_echo "disabled" >&6; }
12627 12627 else
12628 12628 # Check if the provided tool contains a complete path.
12629 12629 tool_specified="$WC"
12630 12630 tool_basename="${tool_specified##*/}"
12631 12631 if test "x$tool_basename" = "x$tool_specified"; then
12632 12632 # A command without a complete path is provided, search $PATH.
12633 12633 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
12634 12634 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
12635 12635 # Extract the first word of "$tool_basename", so it can be a program name with args.
12636 12636 set dummy $tool_basename; ac_word=$2
12637 12637 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12638 12638 $as_echo_n "checking for $ac_word... " >&6; }
12639 12639 if ${ac_cv_path_WC+:} false; then :
12640 12640 $as_echo_n "(cached) " >&6
12641 12641 else
12642 12642 case $WC in
12643 12643 [\\/]* | ?:[\\/]*)
12644 12644 ac_cv_path_WC="$WC" # Let the user override the test with a path.
12645 12645 ;;
12646 12646 *)
12647 12647 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12648 12648 for as_dir in $PATH
12649 12649 do
12650 12650 IFS=$as_save_IFS
12651 12651 test -z "$as_dir" && as_dir=.
12652 12652 for ac_exec_ext in '' $ac_executable_extensions; do
12653 12653 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12654 12654 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12655 12655 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12656 12656 break 2
12657 12657 fi
12658 12658 done
12659 12659 done
12660 12660 IFS=$as_save_IFS
12661 12661
12662 12662 ;;
12663 12663 esac
12664 12664 fi
12665 12665 WC=$ac_cv_path_WC
12666 12666 if test -n "$WC"; then
12667 12667 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12668 12668 $as_echo "$WC" >&6; }
12669 12669 else
12670 12670 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12671 12671 $as_echo "no" >&6; }
12672 12672 fi
12673 12673
12674 12674
12675 12675 if test "x$WC" = x; then
12676 12676 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12677 12677 fi
12678 12678 else
12679 12679 # Otherwise we believe it is a complete path. Use it as it is.
12680 12680 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
12681 12681 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
12682 12682 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12683 12683 $as_echo_n "checking for WC... " >&6; }
12684 12684 if test ! -x "$tool_specified"; then
12685 12685 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12686 12686 $as_echo "not found" >&6; }
12687 12687 as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
12688 12688 fi
12689 12689 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12690 12690 $as_echo "$tool_specified" >&6; }
12691 12691 fi
12692 12692 fi
12693 12693 fi
12694 12694
12695 12695 fi
12696 12696
12697 12697
12698 12698
12699 12699 if test "x$WC" = x; then
12700 12700 as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
12701 12701 fi
12702 12702
12703 12703
12704 12704
12705 12705
12706 12706
12707 12707 # Publish this variable in the help.
12708 12708
12709 12709
12710 12710 if [ -z "${WHICH+x}" ]; then
12711 12711 # The variable is not set by user, try to locate tool using the code snippet
12712 12712 for ac_prog in which
12713 12713 do
12714 12714 # Extract the first word of "$ac_prog", so it can be a program name with args.
12715 12715 set dummy $ac_prog; ac_word=$2
12716 12716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12717 12717 $as_echo_n "checking for $ac_word... " >&6; }
12718 12718 if ${ac_cv_path_WHICH+:} false; then :
12719 12719 $as_echo_n "(cached) " >&6
12720 12720 else
12721 12721 case $WHICH in
12722 12722 [\\/]* | ?:[\\/]*)
12723 12723 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12724 12724 ;;
12725 12725 *)
12726 12726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12727 12727 for as_dir in $PATH
12728 12728 do
12729 12729 IFS=$as_save_IFS
12730 12730 test -z "$as_dir" && as_dir=.
12731 12731 for ac_exec_ext in '' $ac_executable_extensions; do
12732 12732 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12733 12733 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12734 12734 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12735 12735 break 2
12736 12736 fi
12737 12737 done
12738 12738 done
12739 12739 IFS=$as_save_IFS
12740 12740
12741 12741 ;;
12742 12742 esac
12743 12743 fi
12744 12744 WHICH=$ac_cv_path_WHICH
12745 12745 if test -n "$WHICH"; then
12746 12746 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12747 12747 $as_echo "$WHICH" >&6; }
12748 12748 else
12749 12749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12750 12750 $as_echo "no" >&6; }
12751 12751 fi
12752 12752
12753 12753
12754 12754 test -n "$WHICH" && break
12755 12755 done
12756 12756
12757 12757 else
12758 12758 # The variable is set, but is it from the command line or the environment?
12759 12759
12760 12760 # Try to remove the string !WHICH! from our list.
12761 12761 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
12762 12762 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12763 12763 # If it failed, the variable was not from the command line. Ignore it,
12764 12764 # but warn the user (except for BASH, which is always set by the calling BASH).
12765 12765 if test "xWHICH" != xBASH; then
12766 12766 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
12767 12767 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
12768 12768 fi
12769 12769 # Try to locate tool using the code snippet
12770 12770 for ac_prog in which
12771 12771 do
12772 12772 # Extract the first word of "$ac_prog", so it can be a program name with args.
12773 12773 set dummy $ac_prog; ac_word=$2
12774 12774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12775 12775 $as_echo_n "checking for $ac_word... " >&6; }
12776 12776 if ${ac_cv_path_WHICH+:} false; then :
12777 12777 $as_echo_n "(cached) " >&6
12778 12778 else
12779 12779 case $WHICH in
12780 12780 [\\/]* | ?:[\\/]*)
12781 12781 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12782 12782 ;;
12783 12783 *)
12784 12784 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12785 12785 for as_dir in $PATH
12786 12786 do
12787 12787 IFS=$as_save_IFS
12788 12788 test -z "$as_dir" && as_dir=.
12789 12789 for ac_exec_ext in '' $ac_executable_extensions; do
12790 12790 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12791 12791 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12792 12792 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12793 12793 break 2
12794 12794 fi
12795 12795 done
12796 12796 done
12797 12797 IFS=$as_save_IFS
12798 12798
12799 12799 ;;
12800 12800 esac
12801 12801 fi
12802 12802 WHICH=$ac_cv_path_WHICH
12803 12803 if test -n "$WHICH"; then
12804 12804 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12805 12805 $as_echo "$WHICH" >&6; }
12806 12806 else
12807 12807 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12808 12808 $as_echo "no" >&6; }
12809 12809 fi
12810 12810
12811 12811
12812 12812 test -n "$WHICH" && break
12813 12813 done
12814 12814
12815 12815 else
12816 12816 # If it succeeded, then it was overridden by the user. We will use it
12817 12817 # for the tool.
12818 12818
12819 12819 # First remove it from the list of overridden variables, so we can test
12820 12820 # for unknown variables in the end.
12821 12821 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12822 12822
12823 12823 # Check if we try to supply an empty value
12824 12824 if test "x$WHICH" = x; then
12825 12825 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12826 12826 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12827 12827 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12828 12828 $as_echo_n "checking for WHICH... " >&6; }
12829 12829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12830 12830 $as_echo "disabled" >&6; }
12831 12831 else
12832 12832 # Check if the provided tool contains a complete path.
12833 12833 tool_specified="$WHICH"
12834 12834 tool_basename="${tool_specified##*/}"
12835 12835 if test "x$tool_basename" = "x$tool_specified"; then
12836 12836 # A command without a complete path is provided, search $PATH.
12837 12837 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12838 12838 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12839 12839 # Extract the first word of "$tool_basename", so it can be a program name with args.
12840 12840 set dummy $tool_basename; ac_word=$2
12841 12841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12842 12842 $as_echo_n "checking for $ac_word... " >&6; }
12843 12843 if ${ac_cv_path_WHICH+:} false; then :
12844 12844 $as_echo_n "(cached) " >&6
12845 12845 else
12846 12846 case $WHICH in
12847 12847 [\\/]* | ?:[\\/]*)
12848 12848 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12849 12849 ;;
12850 12850 *)
12851 12851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12852 12852 for as_dir in $PATH
12853 12853 do
12854 12854 IFS=$as_save_IFS
12855 12855 test -z "$as_dir" && as_dir=.
12856 12856 for ac_exec_ext in '' $ac_executable_extensions; do
12857 12857 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12858 12858 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12859 12859 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12860 12860 break 2
12861 12861 fi
12862 12862 done
12863 12863 done
12864 12864 IFS=$as_save_IFS
12865 12865
12866 12866 ;;
12867 12867 esac
12868 12868 fi
12869 12869 WHICH=$ac_cv_path_WHICH
12870 12870 if test -n "$WHICH"; then
12871 12871 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12872 12872 $as_echo "$WHICH" >&6; }
12873 12873 else
12874 12874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12875 12875 $as_echo "no" >&6; }
12876 12876 fi
12877 12877
12878 12878
12879 12879 if test "x$WHICH" = x; then
12880 12880 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12881 12881 fi
12882 12882 else
12883 12883 # Otherwise we believe it is a complete path. Use it as it is.
12884 12884 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12885 12885 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12886 12886 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12887 12887 $as_echo_n "checking for WHICH... " >&6; }
12888 12888 if test ! -x "$tool_specified"; then
12889 12889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12890 12890 $as_echo "not found" >&6; }
12891 12891 as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12892 12892 fi
12893 12893 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12894 12894 $as_echo "$tool_specified" >&6; }
12895 12895 fi
12896 12896 fi
12897 12897 fi
12898 12898
12899 12899 fi
12900 12900
12901 12901
12902 12902
12903 12903 if test "x$WHICH" = x; then
12904 12904 as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12905 12905 fi
12906 12906
12907 12907
12908 12908
12909 12909
12910 12910
12911 12911 # Publish this variable in the help.
12912 12912
12913 12913
12914 12914 if [ -z "${XARGS+x}" ]; then
12915 12915 # The variable is not set by user, try to locate tool using the code snippet
12916 12916 for ac_prog in xargs
12917 12917 do
12918 12918 # Extract the first word of "$ac_prog", so it can be a program name with args.
12919 12919 set dummy $ac_prog; ac_word=$2
12920 12920 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12921 12921 $as_echo_n "checking for $ac_word... " >&6; }
12922 12922 if ${ac_cv_path_XARGS+:} false; then :
12923 12923 $as_echo_n "(cached) " >&6
12924 12924 else
12925 12925 case $XARGS in
12926 12926 [\\/]* | ?:[\\/]*)
12927 12927 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12928 12928 ;;
12929 12929 *)
12930 12930 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12931 12931 for as_dir in $PATH
12932 12932 do
12933 12933 IFS=$as_save_IFS
12934 12934 test -z "$as_dir" && as_dir=.
12935 12935 for ac_exec_ext in '' $ac_executable_extensions; do
12936 12936 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12937 12937 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12938 12938 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12939 12939 break 2
12940 12940 fi
12941 12941 done
12942 12942 done
12943 12943 IFS=$as_save_IFS
12944 12944
12945 12945 ;;
12946 12946 esac
12947 12947 fi
12948 12948 XARGS=$ac_cv_path_XARGS
12949 12949 if test -n "$XARGS"; then
12950 12950 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12951 12951 $as_echo "$XARGS" >&6; }
12952 12952 else
12953 12953 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12954 12954 $as_echo "no" >&6; }
12955 12955 fi
12956 12956
12957 12957
12958 12958 test -n "$XARGS" && break
12959 12959 done
12960 12960
12961 12961 else
12962 12962 # The variable is set, but is it from the command line or the environment?
12963 12963
12964 12964 # Try to remove the string !XARGS! from our list.
12965 12965 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12966 12966 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12967 12967 # If it failed, the variable was not from the command line. Ignore it,
12968 12968 # but warn the user (except for BASH, which is always set by the calling BASH).
12969 12969 if test "xXARGS" != xBASH; then
12970 12970 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12971 12971 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12972 12972 fi
12973 12973 # Try to locate tool using the code snippet
12974 12974 for ac_prog in xargs
12975 12975 do
12976 12976 # Extract the first word of "$ac_prog", so it can be a program name with args.
12977 12977 set dummy $ac_prog; ac_word=$2
12978 12978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12979 12979 $as_echo_n "checking for $ac_word... " >&6; }
12980 12980 if ${ac_cv_path_XARGS+:} false; then :
12981 12981 $as_echo_n "(cached) " >&6
12982 12982 else
12983 12983 case $XARGS in
12984 12984 [\\/]* | ?:[\\/]*)
12985 12985 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12986 12986 ;;
12987 12987 *)
12988 12988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12989 12989 for as_dir in $PATH
12990 12990 do
12991 12991 IFS=$as_save_IFS
12992 12992 test -z "$as_dir" && as_dir=.
12993 12993 for ac_exec_ext in '' $ac_executable_extensions; do
12994 12994 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12995 12995 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12996 12996 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12997 12997 break 2
12998 12998 fi
12999 12999 done
13000 13000 done
13001 13001 IFS=$as_save_IFS
13002 13002
13003 13003 ;;
13004 13004 esac
13005 13005 fi
13006 13006 XARGS=$ac_cv_path_XARGS
13007 13007 if test -n "$XARGS"; then
13008 13008 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13009 13009 $as_echo "$XARGS" >&6; }
13010 13010 else
13011 13011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13012 13012 $as_echo "no" >&6; }
13013 13013 fi
13014 13014
13015 13015
13016 13016 test -n "$XARGS" && break
13017 13017 done
13018 13018
13019 13019 else
13020 13020 # If it succeeded, then it was overridden by the user. We will use it
13021 13021 # for the tool.
13022 13022
13023 13023 # First remove it from the list of overridden variables, so we can test
13024 13024 # for unknown variables in the end.
13025 13025 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13026 13026
13027 13027 # Check if we try to supply an empty value
13028 13028 if test "x$XARGS" = x; then
13029 13029 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
13030 13030 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
13031 13031 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13032 13032 $as_echo_n "checking for XARGS... " >&6; }
13033 13033 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13034 13034 $as_echo "disabled" >&6; }
13035 13035 else
13036 13036 # Check if the provided tool contains a complete path.
13037 13037 tool_specified="$XARGS"
13038 13038 tool_basename="${tool_specified##*/}"
13039 13039 if test "x$tool_basename" = "x$tool_specified"; then
13040 13040 # A command without a complete path is provided, search $PATH.
13041 13041 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
13042 13042 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
13043 13043 # Extract the first word of "$tool_basename", so it can be a program name with args.
13044 13044 set dummy $tool_basename; ac_word=$2
13045 13045 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13046 13046 $as_echo_n "checking for $ac_word... " >&6; }
13047 13047 if ${ac_cv_path_XARGS+:} false; then :
13048 13048 $as_echo_n "(cached) " >&6
13049 13049 else
13050 13050 case $XARGS in
13051 13051 [\\/]* | ?:[\\/]*)
13052 13052 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
13053 13053 ;;
13054 13054 *)
13055 13055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13056 13056 for as_dir in $PATH
13057 13057 do
13058 13058 IFS=$as_save_IFS
13059 13059 test -z "$as_dir" && as_dir=.
13060 13060 for ac_exec_ext in '' $ac_executable_extensions; do
13061 13061 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13062 13062 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
13063 13063 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13064 13064 break 2
13065 13065 fi
13066 13066 done
13067 13067 done
13068 13068 IFS=$as_save_IFS
13069 13069
13070 13070 ;;
13071 13071 esac
13072 13072 fi
13073 13073 XARGS=$ac_cv_path_XARGS
13074 13074 if test -n "$XARGS"; then
13075 13075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13076 13076 $as_echo "$XARGS" >&6; }
13077 13077 else
13078 13078 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13079 13079 $as_echo "no" >&6; }
13080 13080 fi
13081 13081
13082 13082
13083 13083 if test "x$XARGS" = x; then
13084 13084 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13085 13085 fi
13086 13086 else
13087 13087 # Otherwise we believe it is a complete path. Use it as it is.
13088 13088 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
13089 13089 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
13090 13090 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13091 13091 $as_echo_n "checking for XARGS... " >&6; }
13092 13092 if test ! -x "$tool_specified"; then
13093 13093 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13094 13094 $as_echo "not found" >&6; }
13095 13095 as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
13096 13096 fi
13097 13097 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13098 13098 $as_echo "$tool_specified" >&6; }
13099 13099 fi
13100 13100 fi
13101 13101 fi
13102 13102
13103 13103 fi
13104 13104
13105 13105
13106 13106
13107 13107 if test "x$XARGS" = x; then
13108 13108 as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
13109 13109 fi
13110 13110
13111 13111
13112 13112
13113 13113 # Then required tools that require some special treatment.
13114 13114
13115 13115
13116 13116 # Publish this variable in the help.
13117 13117
13118 13118
13119 13119 if [ -z "${AWK+x}" ]; then
13120 13120 # The variable is not set by user, try to locate tool using the code snippet
13121 13121 for ac_prog in gawk mawk nawk awk
13122 13122 do
13123 13123 # Extract the first word of "$ac_prog", so it can be a program name with args.
13124 13124 set dummy $ac_prog; ac_word=$2
13125 13125 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13126 13126 $as_echo_n "checking for $ac_word... " >&6; }
13127 13127 if ${ac_cv_prog_AWK+:} false; then :
13128 13128 $as_echo_n "(cached) " >&6
13129 13129 else
13130 13130 if test -n "$AWK"; then
13131 13131 ac_cv_prog_AWK="$AWK" # Let the user override the test.
13132 13132 else
13133 13133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13134 13134 for as_dir in $PATH
13135 13135 do
13136 13136 IFS=$as_save_IFS
13137 13137 test -z "$as_dir" && as_dir=.
13138 13138 for ac_exec_ext in '' $ac_executable_extensions; do
13139 13139 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13140 13140 ac_cv_prog_AWK="$ac_prog"
13141 13141 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13142 13142 break 2
13143 13143 fi
13144 13144 done
13145 13145 done
13146 13146 IFS=$as_save_IFS
13147 13147
13148 13148 fi
13149 13149 fi
13150 13150 AWK=$ac_cv_prog_AWK
13151 13151 if test -n "$AWK"; then
13152 13152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13153 13153 $as_echo "$AWK" >&6; }
13154 13154 else
13155 13155 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13156 13156 $as_echo "no" >&6; }
13157 13157 fi
13158 13158
13159 13159
13160 13160 test -n "$AWK" && break
13161 13161 done
13162 13162
13163 13163 else
13164 13164 # The variable is set, but is it from the command line or the environment?
13165 13165
13166 13166 # Try to remove the string !AWK! from our list.
13167 13167 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
13168 13168 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13169 13169 # If it failed, the variable was not from the command line. Ignore it,
13170 13170 # but warn the user (except for BASH, which is always set by the calling BASH).
13171 13171 if test "xAWK" != xBASH; then
13172 13172 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
13173 13173 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
13174 13174 fi
13175 13175 # Try to locate tool using the code snippet
13176 13176 for ac_prog in gawk mawk nawk awk
13177 13177 do
13178 13178 # Extract the first word of "$ac_prog", so it can be a program name with args.
13179 13179 set dummy $ac_prog; ac_word=$2
13180 13180 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13181 13181 $as_echo_n "checking for $ac_word... " >&6; }
13182 13182 if ${ac_cv_prog_AWK+:} false; then :
13183 13183 $as_echo_n "(cached) " >&6
13184 13184 else
13185 13185 if test -n "$AWK"; then
13186 13186 ac_cv_prog_AWK="$AWK" # Let the user override the test.
13187 13187 else
13188 13188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13189 13189 for as_dir in $PATH
13190 13190 do
13191 13191 IFS=$as_save_IFS
13192 13192 test -z "$as_dir" && as_dir=.
13193 13193 for ac_exec_ext in '' $ac_executable_extensions; do
13194 13194 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13195 13195 ac_cv_prog_AWK="$ac_prog"
13196 13196 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13197 13197 break 2
13198 13198 fi
13199 13199 done
13200 13200 done
13201 13201 IFS=$as_save_IFS
13202 13202
13203 13203 fi
13204 13204 fi
13205 13205 AWK=$ac_cv_prog_AWK
13206 13206 if test -n "$AWK"; then
13207 13207 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13208 13208 $as_echo "$AWK" >&6; }
13209 13209 else
13210 13210 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13211 13211 $as_echo "no" >&6; }
13212 13212 fi
13213 13213
13214 13214
13215 13215 test -n "$AWK" && break
13216 13216 done
13217 13217
13218 13218 else
13219 13219 # If it succeeded, then it was overridden by the user. We will use it
13220 13220 # for the tool.
13221 13221
13222 13222 # First remove it from the list of overridden variables, so we can test
13223 13223 # for unknown variables in the end.
13224 13224 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13225 13225
13226 13226 # Check if we try to supply an empty value
13227 13227 if test "x$AWK" = x; then
13228 13228 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
13229 13229 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
13230 13230 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13231 13231 $as_echo_n "checking for AWK... " >&6; }
13232 13232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13233 13233 $as_echo "disabled" >&6; }
13234 13234 else
13235 13235 # Check if the provided tool contains a complete path.
13236 13236 tool_specified="$AWK"
13237 13237 tool_basename="${tool_specified##*/}"
13238 13238 if test "x$tool_basename" = "x$tool_specified"; then
13239 13239 # A command without a complete path is provided, search $PATH.
13240 13240 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
13241 13241 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
13242 13242 # Extract the first word of "$tool_basename", so it can be a program name with args.
13243 13243 set dummy $tool_basename; ac_word=$2
13244 13244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13245 13245 $as_echo_n "checking for $ac_word... " >&6; }
13246 13246 if ${ac_cv_path_AWK+:} false; then :
13247 13247 $as_echo_n "(cached) " >&6
13248 13248 else
13249 13249 case $AWK in
13250 13250 [\\/]* | ?:[\\/]*)
13251 13251 ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
13252 13252 ;;
13253 13253 *)
13254 13254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13255 13255 for as_dir in $PATH
13256 13256 do
13257 13257 IFS=$as_save_IFS
13258 13258 test -z "$as_dir" && as_dir=.
13259 13259 for ac_exec_ext in '' $ac_executable_extensions; do
13260 13260 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13261 13261 ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
13262 13262 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13263 13263 break 2
13264 13264 fi
13265 13265 done
13266 13266 done
13267 13267 IFS=$as_save_IFS
13268 13268
13269 13269 ;;
13270 13270 esac
13271 13271 fi
13272 13272 AWK=$ac_cv_path_AWK
13273 13273 if test -n "$AWK"; then
13274 13274 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13275 13275 $as_echo "$AWK" >&6; }
13276 13276 else
13277 13277 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13278 13278 $as_echo "no" >&6; }
13279 13279 fi
13280 13280
13281 13281
13282 13282 if test "x$AWK" = x; then
13283 13283 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13284 13284 fi
13285 13285 else
13286 13286 # Otherwise we believe it is a complete path. Use it as it is.
13287 13287 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
13288 13288 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
13289 13289 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13290 13290 $as_echo_n "checking for AWK... " >&6; }
13291 13291 if test ! -x "$tool_specified"; then
13292 13292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13293 13293 $as_echo "not found" >&6; }
13294 13294 as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
13295 13295 fi
13296 13296 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13297 13297 $as_echo "$tool_specified" >&6; }
13298 13298 fi
13299 13299 fi
13300 13300 fi
13301 13301
13302 13302 fi
13303 13303
13304 13304
13305 13305 if test "x$AWK" = x; then
13306 13306 as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
13307 13307 fi
13308 13308
13309 13309
13310 13310
13311 13311
13312 13312 # Publish this variable in the help.
13313 13313
13314 13314
13315 13315 if [ -z "${GREP+x}" ]; then
13316 13316 # The variable is not set by user, try to locate tool using the code snippet
13317 13317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13318 13318 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13319 13319 if ${ac_cv_path_GREP+:} false; then :
13320 13320 $as_echo_n "(cached) " >&6
13321 13321 else
13322 13322 if test -z "$GREP"; then
13323 13323 ac_path_GREP_found=false
13324 13324 # Loop through the user's path and test for each of PROGNAME-LIST
13325 13325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13326 13326 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13327 13327 do
13328 13328 IFS=$as_save_IFS
13329 13329 test -z "$as_dir" && as_dir=.
13330 13330 for ac_prog in grep ggrep; do
13331 13331 for ac_exec_ext in '' $ac_executable_extensions; do
13332 13332 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13333 13333 as_fn_executable_p "$ac_path_GREP" || continue
13334 13334 # Check for GNU ac_path_GREP and select it if it is found.
13335 13335 # Check for GNU $ac_path_GREP
13336 13336 case `"$ac_path_GREP" --version 2>&1` in
13337 13337 *GNU*)
13338 13338 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13339 13339 *)
13340 13340 ac_count=0
13341 13341 $as_echo_n 0123456789 >"conftest.in"
13342 13342 while :
13343 13343 do
13344 13344 cat "conftest.in" "conftest.in" >"conftest.tmp"
13345 13345 mv "conftest.tmp" "conftest.in"
13346 13346 cp "conftest.in" "conftest.nl"
13347 13347 $as_echo 'GREP' >> "conftest.nl"
13348 13348 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13349 13349 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13350 13350 as_fn_arith $ac_count + 1 && ac_count=$as_val
13351 13351 if test $ac_count -gt ${ac_path_GREP_max-0}; then
13352 13352 # Best one so far, save it but keep looking for a better one
13353 13353 ac_cv_path_GREP="$ac_path_GREP"
13354 13354 ac_path_GREP_max=$ac_count
13355 13355 fi
13356 13356 # 10*(2^10) chars as input seems more than enough
13357 13357 test $ac_count -gt 10 && break
13358 13358 done
13359 13359 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13360 13360 esac
13361 13361
13362 13362 $ac_path_GREP_found && break 3
13363 13363 done
13364 13364 done
13365 13365 done
13366 13366 IFS=$as_save_IFS
13367 13367 if test -z "$ac_cv_path_GREP"; then
13368 13368 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13369 13369 fi
13370 13370 else
13371 13371 ac_cv_path_GREP=$GREP
13372 13372 fi
13373 13373
13374 13374 fi
13375 13375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13376 13376 $as_echo "$ac_cv_path_GREP" >&6; }
13377 13377 GREP="$ac_cv_path_GREP"
13378 13378
13379 13379
13380 13380 else
13381 13381 # The variable is set, but is it from the command line or the environment?
13382 13382
13383 13383 # Try to remove the string !GREP! from our list.
13384 13384 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
13385 13385 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13386 13386 # If it failed, the variable was not from the command line. Ignore it,
13387 13387 # but warn the user (except for BASH, which is always set by the calling BASH).
13388 13388 if test "xGREP" != xBASH; then
13389 13389 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
13390 13390 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
13391 13391 fi
13392 13392 # Try to locate tool using the code snippet
13393 13393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13394 13394 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13395 13395 if ${ac_cv_path_GREP+:} false; then :
13396 13396 $as_echo_n "(cached) " >&6
13397 13397 else
13398 13398 if test -z "$GREP"; then
13399 13399 ac_path_GREP_found=false
13400 13400 # Loop through the user's path and test for each of PROGNAME-LIST
13401 13401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13402 13402 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13403 13403 do
13404 13404 IFS=$as_save_IFS
13405 13405 test -z "$as_dir" && as_dir=.
13406 13406 for ac_prog in grep ggrep; do
13407 13407 for ac_exec_ext in '' $ac_executable_extensions; do
13408 13408 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13409 13409 as_fn_executable_p "$ac_path_GREP" || continue
13410 13410 # Check for GNU ac_path_GREP and select it if it is found.
13411 13411 # Check for GNU $ac_path_GREP
13412 13412 case `"$ac_path_GREP" --version 2>&1` in
13413 13413 *GNU*)
13414 13414 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13415 13415 *)
13416 13416 ac_count=0
13417 13417 $as_echo_n 0123456789 >"conftest.in"
13418 13418 while :
13419 13419 do
13420 13420 cat "conftest.in" "conftest.in" >"conftest.tmp"
13421 13421 mv "conftest.tmp" "conftest.in"
13422 13422 cp "conftest.in" "conftest.nl"
13423 13423 $as_echo 'GREP' >> "conftest.nl"
13424 13424 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13425 13425 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13426 13426 as_fn_arith $ac_count + 1 && ac_count=$as_val
13427 13427 if test $ac_count -gt ${ac_path_GREP_max-0}; then
13428 13428 # Best one so far, save it but keep looking for a better one
13429 13429 ac_cv_path_GREP="$ac_path_GREP"
13430 13430 ac_path_GREP_max=$ac_count
13431 13431 fi
13432 13432 # 10*(2^10) chars as input seems more than enough
13433 13433 test $ac_count -gt 10 && break
13434 13434 done
13435 13435 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13436 13436 esac
13437 13437
13438 13438 $ac_path_GREP_found && break 3
13439 13439 done
13440 13440 done
13441 13441 done
13442 13442 IFS=$as_save_IFS
13443 13443 if test -z "$ac_cv_path_GREP"; then
13444 13444 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13445 13445 fi
13446 13446 else
13447 13447 ac_cv_path_GREP=$GREP
13448 13448 fi
13449 13449
13450 13450 fi
13451 13451 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13452 13452 $as_echo "$ac_cv_path_GREP" >&6; }
13453 13453 GREP="$ac_cv_path_GREP"
13454 13454
13455 13455
13456 13456 else
13457 13457 # If it succeeded, then it was overridden by the user. We will use it
13458 13458 # for the tool.
13459 13459
13460 13460 # First remove it from the list of overridden variables, so we can test
13461 13461 # for unknown variables in the end.
13462 13462 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13463 13463
13464 13464 # Check if we try to supply an empty value
13465 13465 if test "x$GREP" = x; then
13466 13466 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
13467 13467 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
13468 13468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13469 13469 $as_echo_n "checking for GREP... " >&6; }
13470 13470 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13471 13471 $as_echo "disabled" >&6; }
13472 13472 else
13473 13473 # Check if the provided tool contains a complete path.
13474 13474 tool_specified="$GREP"
13475 13475 tool_basename="${tool_specified##*/}"
13476 13476 if test "x$tool_basename" = "x$tool_specified"; then
13477 13477 # A command without a complete path is provided, search $PATH.
13478 13478 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
13479 13479 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
13480 13480 # Extract the first word of "$tool_basename", so it can be a program name with args.
13481 13481 set dummy $tool_basename; ac_word=$2
13482 13482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13483 13483 $as_echo_n "checking for $ac_word... " >&6; }
13484 13484 if ${ac_cv_path_GREP+:} false; then :
13485 13485 $as_echo_n "(cached) " >&6
13486 13486 else
13487 13487 case $GREP in
13488 13488 [\\/]* | ?:[\\/]*)
13489 13489 ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
13490 13490 ;;
13491 13491 *)
13492 13492 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13493 13493 for as_dir in $PATH
13494 13494 do
13495 13495 IFS=$as_save_IFS
13496 13496 test -z "$as_dir" && as_dir=.
13497 13497 for ac_exec_ext in '' $ac_executable_extensions; do
13498 13498 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13499 13499 ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
13500 13500 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13501 13501 break 2
13502 13502 fi
13503 13503 done
13504 13504 done
13505 13505 IFS=$as_save_IFS
13506 13506
13507 13507 ;;
13508 13508 esac
13509 13509 fi
13510 13510 GREP=$ac_cv_path_GREP
13511 13511 if test -n "$GREP"; then
13512 13512 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
13513 13513 $as_echo "$GREP" >&6; }
13514 13514 else
13515 13515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13516 13516 $as_echo "no" >&6; }
13517 13517 fi
13518 13518
13519 13519
13520 13520 if test "x$GREP" = x; then
13521 13521 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13522 13522 fi
13523 13523 else
13524 13524 # Otherwise we believe it is a complete path. Use it as it is.
13525 13525 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
13526 13526 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
13527 13527 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13528 13528 $as_echo_n "checking for GREP... " >&6; }
13529 13529 if test ! -x "$tool_specified"; then
13530 13530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13531 13531 $as_echo "not found" >&6; }
13532 13532 as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13533 13533 fi
13534 13534 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13535 13535 $as_echo "$tool_specified" >&6; }
13536 13536 fi
13537 13537 fi
13538 13538 fi
13539 13539
13540 13540 fi
13541 13541
13542 13542
13543 13543 if test "x$GREP" = x; then
13544 13544 as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
13545 13545 fi
13546 13546
13547 13547
13548 13548
13549 13549
13550 13550 # Publish this variable in the help.
13551 13551
13552 13552
13553 13553 if [ -z "${EGREP+x}" ]; then
13554 13554 # The variable is not set by user, try to locate tool using the code snippet
13555 13555 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13556 13556 $as_echo_n "checking for egrep... " >&6; }
13557 13557 if ${ac_cv_path_EGREP+:} false; then :
13558 13558 $as_echo_n "(cached) " >&6
13559 13559 else
13560 13560 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13561 13561 then ac_cv_path_EGREP="$GREP -E"
13562 13562 else
13563 13563 if test -z "$EGREP"; then
13564 13564 ac_path_EGREP_found=false
13565 13565 # Loop through the user's path and test for each of PROGNAME-LIST
13566 13566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13567 13567 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13568 13568 do
13569 13569 IFS=$as_save_IFS
13570 13570 test -z "$as_dir" && as_dir=.
13571 13571 for ac_prog in egrep; do
13572 13572 for ac_exec_ext in '' $ac_executable_extensions; do
13573 13573 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13574 13574 as_fn_executable_p "$ac_path_EGREP" || continue
13575 13575 # Check for GNU ac_path_EGREP and select it if it is found.
13576 13576 # Check for GNU $ac_path_EGREP
13577 13577 case `"$ac_path_EGREP" --version 2>&1` in
13578 13578 *GNU*)
13579 13579 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13580 13580 *)
13581 13581 ac_count=0
13582 13582 $as_echo_n 0123456789 >"conftest.in"
13583 13583 while :
13584 13584 do
13585 13585 cat "conftest.in" "conftest.in" >"conftest.tmp"
13586 13586 mv "conftest.tmp" "conftest.in"
13587 13587 cp "conftest.in" "conftest.nl"
13588 13588 $as_echo 'EGREP' >> "conftest.nl"
13589 13589 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13590 13590 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13591 13591 as_fn_arith $ac_count + 1 && ac_count=$as_val
13592 13592 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13593 13593 # Best one so far, save it but keep looking for a better one
13594 13594 ac_cv_path_EGREP="$ac_path_EGREP"
13595 13595 ac_path_EGREP_max=$ac_count
13596 13596 fi
13597 13597 # 10*(2^10) chars as input seems more than enough
13598 13598 test $ac_count -gt 10 && break
13599 13599 done
13600 13600 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13601 13601 esac
13602 13602
13603 13603 $ac_path_EGREP_found && break 3
13604 13604 done
13605 13605 done
13606 13606 done
13607 13607 IFS=$as_save_IFS
13608 13608 if test -z "$ac_cv_path_EGREP"; then
13609 13609 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13610 13610 fi
13611 13611 else
13612 13612 ac_cv_path_EGREP=$EGREP
13613 13613 fi
13614 13614
13615 13615 fi
13616 13616 fi
13617 13617 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13618 13618 $as_echo "$ac_cv_path_EGREP" >&6; }
13619 13619 EGREP="$ac_cv_path_EGREP"
13620 13620
13621 13621
13622 13622 else
13623 13623 # The variable is set, but is it from the command line or the environment?
13624 13624
13625 13625 # Try to remove the string !EGREP! from our list.
13626 13626 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
13627 13627 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13628 13628 # If it failed, the variable was not from the command line. Ignore it,
13629 13629 # but warn the user (except for BASH, which is always set by the calling BASH).
13630 13630 if test "xEGREP" != xBASH; then
13631 13631 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
13632 13632 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
13633 13633 fi
13634 13634 # Try to locate tool using the code snippet
13635 13635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13636 13636 $as_echo_n "checking for egrep... " >&6; }
13637 13637 if ${ac_cv_path_EGREP+:} false; then :
13638 13638 $as_echo_n "(cached) " >&6
13639 13639 else
13640 13640 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13641 13641 then ac_cv_path_EGREP="$GREP -E"
13642 13642 else
13643 13643 if test -z "$EGREP"; then
13644 13644 ac_path_EGREP_found=false
13645 13645 # Loop through the user's path and test for each of PROGNAME-LIST
13646 13646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13647 13647 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13648 13648 do
13649 13649 IFS=$as_save_IFS
13650 13650 test -z "$as_dir" && as_dir=.
13651 13651 for ac_prog in egrep; do
13652 13652 for ac_exec_ext in '' $ac_executable_extensions; do
13653 13653 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13654 13654 as_fn_executable_p "$ac_path_EGREP" || continue
13655 13655 # Check for GNU ac_path_EGREP and select it if it is found.
13656 13656 # Check for GNU $ac_path_EGREP
13657 13657 case `"$ac_path_EGREP" --version 2>&1` in
13658 13658 *GNU*)
13659 13659 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13660 13660 *)
13661 13661 ac_count=0
13662 13662 $as_echo_n 0123456789 >"conftest.in"
13663 13663 while :
13664 13664 do
13665 13665 cat "conftest.in" "conftest.in" >"conftest.tmp"
13666 13666 mv "conftest.tmp" "conftest.in"
13667 13667 cp "conftest.in" "conftest.nl"
13668 13668 $as_echo 'EGREP' >> "conftest.nl"
13669 13669 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13670 13670 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13671 13671 as_fn_arith $ac_count + 1 && ac_count=$as_val
13672 13672 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13673 13673 # Best one so far, save it but keep looking for a better one
13674 13674 ac_cv_path_EGREP="$ac_path_EGREP"
13675 13675 ac_path_EGREP_max=$ac_count
13676 13676 fi
13677 13677 # 10*(2^10) chars as input seems more than enough
13678 13678 test $ac_count -gt 10 && break
13679 13679 done
13680 13680 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13681 13681 esac
13682 13682
13683 13683 $ac_path_EGREP_found && break 3
13684 13684 done
13685 13685 done
13686 13686 done
13687 13687 IFS=$as_save_IFS
13688 13688 if test -z "$ac_cv_path_EGREP"; then
13689 13689 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13690 13690 fi
13691 13691 else
13692 13692 ac_cv_path_EGREP=$EGREP
13693 13693 fi
13694 13694
13695 13695 fi
13696 13696 fi
13697 13697 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13698 13698 $as_echo "$ac_cv_path_EGREP" >&6; }
13699 13699 EGREP="$ac_cv_path_EGREP"
13700 13700
13701 13701
13702 13702 else
13703 13703 # If it succeeded, then it was overridden by the user. We will use it
13704 13704 # for the tool.
13705 13705
13706 13706 # First remove it from the list of overridden variables, so we can test
13707 13707 # for unknown variables in the end.
13708 13708 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13709 13709
13710 13710 # Check if we try to supply an empty value
13711 13711 if test "x$EGREP" = x; then
13712 13712 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
13713 13713 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
13714 13714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13715 13715 $as_echo_n "checking for EGREP... " >&6; }
13716 13716 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13717 13717 $as_echo "disabled" >&6; }
13718 13718 else
13719 13719 # Check if the provided tool contains a complete path.
13720 13720 tool_specified="$EGREP"
13721 13721 tool_basename="${tool_specified##*/}"
13722 13722 if test "x$tool_basename" = "x$tool_specified"; then
13723 13723 # A command without a complete path is provided, search $PATH.
13724 13724 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
13725 13725 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
13726 13726 # Extract the first word of "$tool_basename", so it can be a program name with args.
13727 13727 set dummy $tool_basename; ac_word=$2
13728 13728 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13729 13729 $as_echo_n "checking for $ac_word... " >&6; }
13730 13730 if ${ac_cv_path_EGREP+:} false; then :
13731 13731 $as_echo_n "(cached) " >&6
13732 13732 else
13733 13733 case $EGREP in
13734 13734 [\\/]* | ?:[\\/]*)
13735 13735 ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
13736 13736 ;;
13737 13737 *)
13738 13738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13739 13739 for as_dir in $PATH
13740 13740 do
13741 13741 IFS=$as_save_IFS
13742 13742 test -z "$as_dir" && as_dir=.
13743 13743 for ac_exec_ext in '' $ac_executable_extensions; do
13744 13744 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13745 13745 ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
13746 13746 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13747 13747 break 2
13748 13748 fi
13749 13749 done
13750 13750 done
13751 13751 IFS=$as_save_IFS
13752 13752
13753 13753 ;;
13754 13754 esac
13755 13755 fi
13756 13756 EGREP=$ac_cv_path_EGREP
13757 13757 if test -n "$EGREP"; then
13758 13758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
13759 13759 $as_echo "$EGREP" >&6; }
13760 13760 else
13761 13761 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13762 13762 $as_echo "no" >&6; }
13763 13763 fi
13764 13764
13765 13765
13766 13766 if test "x$EGREP" = x; then
13767 13767 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13768 13768 fi
13769 13769 else
13770 13770 # Otherwise we believe it is a complete path. Use it as it is.
13771 13771 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
13772 13772 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
13773 13773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13774 13774 $as_echo_n "checking for EGREP... " >&6; }
13775 13775 if test ! -x "$tool_specified"; then
13776 13776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13777 13777 $as_echo "not found" >&6; }
13778 13778 as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13779 13779 fi
13780 13780 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13781 13781 $as_echo "$tool_specified" >&6; }
13782 13782 fi
13783 13783 fi
13784 13784 fi
13785 13785
13786 13786 fi
13787 13787
13788 13788
13789 13789 if test "x$EGREP" = x; then
13790 13790 as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
13791 13791 fi
13792 13792
13793 13793
13794 13794
13795 13795
13796 13796 # Publish this variable in the help.
13797 13797
13798 13798
13799 13799 if [ -z "${FGREP+x}" ]; then
13800 13800 # The variable is not set by user, try to locate tool using the code snippet
13801 13801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13802 13802 $as_echo_n "checking for fgrep... " >&6; }
13803 13803 if ${ac_cv_path_FGREP+:} false; then :
13804 13804 $as_echo_n "(cached) " >&6
13805 13805 else
13806 13806 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13807 13807 then ac_cv_path_FGREP="$GREP -F"
13808 13808 else
13809 13809 if test -z "$FGREP"; then
13810 13810 ac_path_FGREP_found=false
13811 13811 # Loop through the user's path and test for each of PROGNAME-LIST
13812 13812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13813 13813 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13814 13814 do
13815 13815 IFS=$as_save_IFS
13816 13816 test -z "$as_dir" && as_dir=.
13817 13817 for ac_prog in fgrep; do
13818 13818 for ac_exec_ext in '' $ac_executable_extensions; do
13819 13819 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13820 13820 as_fn_executable_p "$ac_path_FGREP" || continue
13821 13821 # Check for GNU ac_path_FGREP and select it if it is found.
13822 13822 # Check for GNU $ac_path_FGREP
13823 13823 case `"$ac_path_FGREP" --version 2>&1` in
13824 13824 *GNU*)
13825 13825 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13826 13826 *)
13827 13827 ac_count=0
13828 13828 $as_echo_n 0123456789 >"conftest.in"
13829 13829 while :
13830 13830 do
13831 13831 cat "conftest.in" "conftest.in" >"conftest.tmp"
13832 13832 mv "conftest.tmp" "conftest.in"
13833 13833 cp "conftest.in" "conftest.nl"
13834 13834 $as_echo 'FGREP' >> "conftest.nl"
13835 13835 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13836 13836 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13837 13837 as_fn_arith $ac_count + 1 && ac_count=$as_val
13838 13838 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13839 13839 # Best one so far, save it but keep looking for a better one
13840 13840 ac_cv_path_FGREP="$ac_path_FGREP"
13841 13841 ac_path_FGREP_max=$ac_count
13842 13842 fi
13843 13843 # 10*(2^10) chars as input seems more than enough
13844 13844 test $ac_count -gt 10 && break
13845 13845 done
13846 13846 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13847 13847 esac
13848 13848
13849 13849 $ac_path_FGREP_found && break 3
13850 13850 done
13851 13851 done
13852 13852 done
13853 13853 IFS=$as_save_IFS
13854 13854 if test -z "$ac_cv_path_FGREP"; then
13855 13855 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13856 13856 fi
13857 13857 else
13858 13858 ac_cv_path_FGREP=$FGREP
13859 13859 fi
13860 13860
13861 13861 fi
13862 13862 fi
13863 13863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13864 13864 $as_echo "$ac_cv_path_FGREP" >&6; }
13865 13865 FGREP="$ac_cv_path_FGREP"
13866 13866
13867 13867
13868 13868 else
13869 13869 # The variable is set, but is it from the command line or the environment?
13870 13870
13871 13871 # Try to remove the string !FGREP! from our list.
13872 13872 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13873 13873 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13874 13874 # If it failed, the variable was not from the command line. Ignore it,
13875 13875 # but warn the user (except for BASH, which is always set by the calling BASH).
13876 13876 if test "xFGREP" != xBASH; then
13877 13877 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13878 13878 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13879 13879 fi
13880 13880 # Try to locate tool using the code snippet
13881 13881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13882 13882 $as_echo_n "checking for fgrep... " >&6; }
13883 13883 if ${ac_cv_path_FGREP+:} false; then :
13884 13884 $as_echo_n "(cached) " >&6
13885 13885 else
13886 13886 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13887 13887 then ac_cv_path_FGREP="$GREP -F"
13888 13888 else
13889 13889 if test -z "$FGREP"; then
13890 13890 ac_path_FGREP_found=false
13891 13891 # Loop through the user's path and test for each of PROGNAME-LIST
13892 13892 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13893 13893 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13894 13894 do
13895 13895 IFS=$as_save_IFS
13896 13896 test -z "$as_dir" && as_dir=.
13897 13897 for ac_prog in fgrep; do
13898 13898 for ac_exec_ext in '' $ac_executable_extensions; do
13899 13899 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13900 13900 as_fn_executable_p "$ac_path_FGREP" || continue
13901 13901 # Check for GNU ac_path_FGREP and select it if it is found.
13902 13902 # Check for GNU $ac_path_FGREP
13903 13903 case `"$ac_path_FGREP" --version 2>&1` in
13904 13904 *GNU*)
13905 13905 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13906 13906 *)
13907 13907 ac_count=0
13908 13908 $as_echo_n 0123456789 >"conftest.in"
13909 13909 while :
13910 13910 do
13911 13911 cat "conftest.in" "conftest.in" >"conftest.tmp"
13912 13912 mv "conftest.tmp" "conftest.in"
13913 13913 cp "conftest.in" "conftest.nl"
13914 13914 $as_echo 'FGREP' >> "conftest.nl"
13915 13915 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13916 13916 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13917 13917 as_fn_arith $ac_count + 1 && ac_count=$as_val
13918 13918 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13919 13919 # Best one so far, save it but keep looking for a better one
13920 13920 ac_cv_path_FGREP="$ac_path_FGREP"
13921 13921 ac_path_FGREP_max=$ac_count
13922 13922 fi
13923 13923 # 10*(2^10) chars as input seems more than enough
13924 13924 test $ac_count -gt 10 && break
13925 13925 done
13926 13926 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13927 13927 esac
13928 13928
13929 13929 $ac_path_FGREP_found && break 3
13930 13930 done
13931 13931 done
13932 13932 done
13933 13933 IFS=$as_save_IFS
13934 13934 if test -z "$ac_cv_path_FGREP"; then
13935 13935 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13936 13936 fi
13937 13937 else
13938 13938 ac_cv_path_FGREP=$FGREP
13939 13939 fi
13940 13940
13941 13941 fi
13942 13942 fi
13943 13943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13944 13944 $as_echo "$ac_cv_path_FGREP" >&6; }
13945 13945 FGREP="$ac_cv_path_FGREP"
13946 13946
13947 13947
13948 13948 else
13949 13949 # If it succeeded, then it was overridden by the user. We will use it
13950 13950 # for the tool.
13951 13951
13952 13952 # First remove it from the list of overridden variables, so we can test
13953 13953 # for unknown variables in the end.
13954 13954 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13955 13955
13956 13956 # Check if we try to supply an empty value
13957 13957 if test "x$FGREP" = x; then
13958 13958 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13959 13959 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13960 13960 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13961 13961 $as_echo_n "checking for FGREP... " >&6; }
13962 13962 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13963 13963 $as_echo "disabled" >&6; }
13964 13964 else
13965 13965 # Check if the provided tool contains a complete path.
13966 13966 tool_specified="$FGREP"
13967 13967 tool_basename="${tool_specified##*/}"
13968 13968 if test "x$tool_basename" = "x$tool_specified"; then
13969 13969 # A command without a complete path is provided, search $PATH.
13970 13970 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13971 13971 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13972 13972 # Extract the first word of "$tool_basename", so it can be a program name with args.
13973 13973 set dummy $tool_basename; ac_word=$2
13974 13974 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13975 13975 $as_echo_n "checking for $ac_word... " >&6; }
13976 13976 if ${ac_cv_path_FGREP+:} false; then :
13977 13977 $as_echo_n "(cached) " >&6
13978 13978 else
13979 13979 case $FGREP in
13980 13980 [\\/]* | ?:[\\/]*)
13981 13981 ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13982 13982 ;;
13983 13983 *)
13984 13984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13985 13985 for as_dir in $PATH
13986 13986 do
13987 13987 IFS=$as_save_IFS
13988 13988 test -z "$as_dir" && as_dir=.
13989 13989 for ac_exec_ext in '' $ac_executable_extensions; do
13990 13990 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13991 13991 ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13992 13992 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13993 13993 break 2
13994 13994 fi
13995 13995 done
13996 13996 done
13997 13997 IFS=$as_save_IFS
13998 13998
13999 13999 ;;
14000 14000 esac
14001 14001 fi
14002 14002 FGREP=$ac_cv_path_FGREP
14003 14003 if test -n "$FGREP"; then
14004 14004 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
14005 14005 $as_echo "$FGREP" >&6; }
14006 14006 else
14007 14007 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14008 14008 $as_echo "no" >&6; }
14009 14009 fi
14010 14010
14011 14011
14012 14012 if test "x$FGREP" = x; then
14013 14013 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14014 14014 fi
14015 14015 else
14016 14016 # Otherwise we believe it is a complete path. Use it as it is.
14017 14017 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
14018 14018 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
14019 14019 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
14020 14020 $as_echo_n "checking for FGREP... " >&6; }
14021 14021 if test ! -x "$tool_specified"; then
14022 14022 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14023 14023 $as_echo "not found" >&6; }
14024 14024 as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
14025 14025 fi
14026 14026 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14027 14027 $as_echo "$tool_specified" >&6; }
14028 14028 fi
14029 14029 fi
14030 14030 fi
14031 14031
14032 14032 fi
14033 14033
14034 14034
14035 14035 if test "x$FGREP" = x; then
14036 14036 as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
14037 14037 fi
14038 14038
14039 14039
14040 14040
14041 14041
14042 14042 # Publish this variable in the help.
14043 14043
14044 14044
14045 14045 if [ -z "${SED+x}" ]; then
14046 14046 # The variable is not set by user, try to locate tool using the code snippet
14047 14047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14048 14048 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14049 14049 if ${ac_cv_path_SED+:} false; then :
14050 14050 $as_echo_n "(cached) " >&6
14051 14051 else
14052 14052 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14053 14053 for ac_i in 1 2 3 4 5 6 7; do
14054 14054 ac_script="$ac_script$as_nl$ac_script"
14055 14055 done
14056 14056 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14057 14057 { ac_script=; unset ac_script;}
14058 14058 if test -z "$SED"; then
14059 14059 ac_path_SED_found=false
14060 14060 # Loop through the user's path and test for each of PROGNAME-LIST
14061 14061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14062 14062 for as_dir in $PATH
14063 14063 do
14064 14064 IFS=$as_save_IFS
14065 14065 test -z "$as_dir" && as_dir=.
14066 14066 for ac_prog in sed gsed; do
14067 14067 for ac_exec_ext in '' $ac_executable_extensions; do
14068 14068 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14069 14069 as_fn_executable_p "$ac_path_SED" || continue
14070 14070 # Check for GNU ac_path_SED and select it if it is found.
14071 14071 # Check for GNU $ac_path_SED
14072 14072 case `"$ac_path_SED" --version 2>&1` in
14073 14073 *GNU*)
14074 14074 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14075 14075 *)
14076 14076 ac_count=0
14077 14077 $as_echo_n 0123456789 >"conftest.in"
14078 14078 while :
14079 14079 do
14080 14080 cat "conftest.in" "conftest.in" >"conftest.tmp"
14081 14081 mv "conftest.tmp" "conftest.in"
14082 14082 cp "conftest.in" "conftest.nl"
14083 14083 $as_echo '' >> "conftest.nl"
14084 14084 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14085 14085 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14086 14086 as_fn_arith $ac_count + 1 && ac_count=$as_val
14087 14087 if test $ac_count -gt ${ac_path_SED_max-0}; then
14088 14088 # Best one so far, save it but keep looking for a better one
14089 14089 ac_cv_path_SED="$ac_path_SED"
14090 14090 ac_path_SED_max=$ac_count
14091 14091 fi
14092 14092 # 10*(2^10) chars as input seems more than enough
14093 14093 test $ac_count -gt 10 && break
14094 14094 done
14095 14095 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14096 14096 esac
14097 14097
14098 14098 $ac_path_SED_found && break 3
14099 14099 done
14100 14100 done
14101 14101 done
14102 14102 IFS=$as_save_IFS
14103 14103 if test -z "$ac_cv_path_SED"; then
14104 14104 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14105 14105 fi
14106 14106 else
14107 14107 ac_cv_path_SED=$SED
14108 14108 fi
14109 14109
14110 14110 fi
14111 14111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14112 14112 $as_echo "$ac_cv_path_SED" >&6; }
14113 14113 SED="$ac_cv_path_SED"
14114 14114 rm -f conftest.sed
14115 14115
14116 14116 else
14117 14117 # The variable is set, but is it from the command line or the environment?
14118 14118
14119 14119 # Try to remove the string !SED! from our list.
14120 14120 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
14121 14121 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14122 14122 # If it failed, the variable was not from the command line. Ignore it,
14123 14123 # but warn the user (except for BASH, which is always set by the calling BASH).
14124 14124 if test "xSED" != xBASH; then
14125 14125 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
14126 14126 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
14127 14127 fi
14128 14128 # Try to locate tool using the code snippet
14129 14129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14130 14130 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14131 14131 if ${ac_cv_path_SED+:} false; then :
14132 14132 $as_echo_n "(cached) " >&6
14133 14133 else
14134 14134 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14135 14135 for ac_i in 1 2 3 4 5 6 7; do
14136 14136 ac_script="$ac_script$as_nl$ac_script"
14137 14137 done
14138 14138 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14139 14139 { ac_script=; unset ac_script;}
14140 14140 if test -z "$SED"; then
14141 14141 ac_path_SED_found=false
14142 14142 # Loop through the user's path and test for each of PROGNAME-LIST
14143 14143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14144 14144 for as_dir in $PATH
14145 14145 do
14146 14146 IFS=$as_save_IFS
14147 14147 test -z "$as_dir" && as_dir=.
14148 14148 for ac_prog in sed gsed; do
14149 14149 for ac_exec_ext in '' $ac_executable_extensions; do
14150 14150 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14151 14151 as_fn_executable_p "$ac_path_SED" || continue
14152 14152 # Check for GNU ac_path_SED and select it if it is found.
14153 14153 # Check for GNU $ac_path_SED
14154 14154 case `"$ac_path_SED" --version 2>&1` in
14155 14155 *GNU*)
14156 14156 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14157 14157 *)
14158 14158 ac_count=0
14159 14159 $as_echo_n 0123456789 >"conftest.in"
14160 14160 while :
14161 14161 do
14162 14162 cat "conftest.in" "conftest.in" >"conftest.tmp"
14163 14163 mv "conftest.tmp" "conftest.in"
14164 14164 cp "conftest.in" "conftest.nl"
14165 14165 $as_echo '' >> "conftest.nl"
14166 14166 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14167 14167 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14168 14168 as_fn_arith $ac_count + 1 && ac_count=$as_val
14169 14169 if test $ac_count -gt ${ac_path_SED_max-0}; then
14170 14170 # Best one so far, save it but keep looking for a better one
14171 14171 ac_cv_path_SED="$ac_path_SED"
14172 14172 ac_path_SED_max=$ac_count
14173 14173 fi
14174 14174 # 10*(2^10) chars as input seems more than enough
14175 14175 test $ac_count -gt 10 && break
14176 14176 done
14177 14177 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14178 14178 esac
14179 14179
14180 14180 $ac_path_SED_found && break 3
14181 14181 done
14182 14182 done
14183 14183 done
14184 14184 IFS=$as_save_IFS
14185 14185 if test -z "$ac_cv_path_SED"; then
14186 14186 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14187 14187 fi
14188 14188 else
14189 14189 ac_cv_path_SED=$SED
14190 14190 fi
14191 14191
14192 14192 fi
14193 14193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14194 14194 $as_echo "$ac_cv_path_SED" >&6; }
14195 14195 SED="$ac_cv_path_SED"
14196 14196 rm -f conftest.sed
14197 14197
14198 14198 else
14199 14199 # If it succeeded, then it was overridden by the user. We will use it
14200 14200 # for the tool.
14201 14201
14202 14202 # First remove it from the list of overridden variables, so we can test
14203 14203 # for unknown variables in the end.
14204 14204 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14205 14205
14206 14206 # Check if we try to supply an empty value
14207 14207 if test "x$SED" = x; then
14208 14208 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
14209 14209 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
14210 14210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14211 14211 $as_echo_n "checking for SED... " >&6; }
14212 14212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14213 14213 $as_echo "disabled" >&6; }
14214 14214 else
14215 14215 # Check if the provided tool contains a complete path.
14216 14216 tool_specified="$SED"
14217 14217 tool_basename="${tool_specified##*/}"
14218 14218 if test "x$tool_basename" = "x$tool_specified"; then
14219 14219 # A command without a complete path is provided, search $PATH.
14220 14220 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
14221 14221 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
14222 14222 # Extract the first word of "$tool_basename", so it can be a program name with args.
14223 14223 set dummy $tool_basename; ac_word=$2
14224 14224 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14225 14225 $as_echo_n "checking for $ac_word... " >&6; }
14226 14226 if ${ac_cv_path_SED+:} false; then :
14227 14227 $as_echo_n "(cached) " >&6
14228 14228 else
14229 14229 case $SED in
14230 14230 [\\/]* | ?:[\\/]*)
14231 14231 ac_cv_path_SED="$SED" # Let the user override the test with a path.
14232 14232 ;;
14233 14233 *)
14234 14234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14235 14235 for as_dir in $PATH
14236 14236 do
14237 14237 IFS=$as_save_IFS
14238 14238 test -z "$as_dir" && as_dir=.
14239 14239 for ac_exec_ext in '' $ac_executable_extensions; do
14240 14240 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14241 14241 ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
14242 14242 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14243 14243 break 2
14244 14244 fi
14245 14245 done
14246 14246 done
14247 14247 IFS=$as_save_IFS
14248 14248
14249 14249 ;;
14250 14250 esac
14251 14251 fi
14252 14252 SED=$ac_cv_path_SED
14253 14253 if test -n "$SED"; then
14254 14254 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
14255 14255 $as_echo "$SED" >&6; }
14256 14256 else
14257 14257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14258 14258 $as_echo "no" >&6; }
14259 14259 fi
14260 14260
14261 14261
14262 14262 if test "x$SED" = x; then
14263 14263 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14264 14264 fi
14265 14265 else
14266 14266 # Otherwise we believe it is a complete path. Use it as it is.
14267 14267 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
14268 14268 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
14269 14269 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14270 14270 $as_echo_n "checking for SED... " >&6; }
14271 14271 if test ! -x "$tool_specified"; then
14272 14272 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14273 14273 $as_echo "not found" >&6; }
14274 14274 as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
14275 14275 fi
14276 14276 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14277 14277 $as_echo "$tool_specified" >&6; }
14278 14278 fi
14279 14279 fi
14280 14280 fi
14281 14281
14282 14282 fi
14283 14283
14284 14284
14285 14285 if test "x$SED" = x; then
14286 14286 as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
14287 14287 fi
14288 14288
14289 14289
14290 14290
14291 14291 # Always force rm.
14292 14292 RM="$RM -f"
14293 14293
14294 14294 # pwd behaves differently on various platforms and some don't support the -L flag.
14295 14295 # Always use the bash builtin pwd to get uniform behavior.
14296 14296 THEPWDCMD=pwd
14297 14297
14298 14298 # These are not required on all platforms
14299 14299
14300 14300
14301 14301 # Publish this variable in the help.
14302 14302
14303 14303
14304 14304 if [ -z "${CYGPATH+x}" ]; then
14305 14305 # The variable is not set by user, try to locate tool using the code snippet
14306 14306 for ac_prog in cygpath
14307 14307 do
14308 14308 # Extract the first word of "$ac_prog", so it can be a program name with args.
14309 14309 set dummy $ac_prog; ac_word=$2
14310 14310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14311 14311 $as_echo_n "checking for $ac_word... " >&6; }
14312 14312 if ${ac_cv_path_CYGPATH+:} false; then :
14313 14313 $as_echo_n "(cached) " >&6
14314 14314 else
14315 14315 case $CYGPATH in
14316 14316 [\\/]* | ?:[\\/]*)
14317 14317 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14318 14318 ;;
14319 14319 *)
14320 14320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14321 14321 for as_dir in $PATH
14322 14322 do
14323 14323 IFS=$as_save_IFS
14324 14324 test -z "$as_dir" && as_dir=.
14325 14325 for ac_exec_ext in '' $ac_executable_extensions; do
14326 14326 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14327 14327 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14328 14328 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14329 14329 break 2
14330 14330 fi
14331 14331 done
14332 14332 done
14333 14333 IFS=$as_save_IFS
14334 14334
14335 14335 ;;
14336 14336 esac
14337 14337 fi
14338 14338 CYGPATH=$ac_cv_path_CYGPATH
14339 14339 if test -n "$CYGPATH"; then
14340 14340 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14341 14341 $as_echo "$CYGPATH" >&6; }
14342 14342 else
14343 14343 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14344 14344 $as_echo "no" >&6; }
14345 14345 fi
14346 14346
14347 14347
14348 14348 test -n "$CYGPATH" && break
14349 14349 done
14350 14350
14351 14351 else
14352 14352 # The variable is set, but is it from the command line or the environment?
14353 14353
14354 14354 # Try to remove the string !CYGPATH! from our list.
14355 14355 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
14356 14356 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14357 14357 # If it failed, the variable was not from the command line. Ignore it,
14358 14358 # but warn the user (except for BASH, which is always set by the calling BASH).
14359 14359 if test "xCYGPATH" != xBASH; then
14360 14360 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
14361 14361 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
14362 14362 fi
14363 14363 # Try to locate tool using the code snippet
14364 14364 for ac_prog in cygpath
14365 14365 do
14366 14366 # Extract the first word of "$ac_prog", so it can be a program name with args.
14367 14367 set dummy $ac_prog; ac_word=$2
14368 14368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14369 14369 $as_echo_n "checking for $ac_word... " >&6; }
14370 14370 if ${ac_cv_path_CYGPATH+:} false; then :
14371 14371 $as_echo_n "(cached) " >&6
14372 14372 else
14373 14373 case $CYGPATH in
14374 14374 [\\/]* | ?:[\\/]*)
14375 14375 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14376 14376 ;;
14377 14377 *)
14378 14378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14379 14379 for as_dir in $PATH
14380 14380 do
14381 14381 IFS=$as_save_IFS
14382 14382 test -z "$as_dir" && as_dir=.
14383 14383 for ac_exec_ext in '' $ac_executable_extensions; do
14384 14384 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14385 14385 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14386 14386 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14387 14387 break 2
14388 14388 fi
14389 14389 done
14390 14390 done
14391 14391 IFS=$as_save_IFS
14392 14392
14393 14393 ;;
14394 14394 esac
14395 14395 fi
14396 14396 CYGPATH=$ac_cv_path_CYGPATH
14397 14397 if test -n "$CYGPATH"; then
14398 14398 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14399 14399 $as_echo "$CYGPATH" >&6; }
14400 14400 else
14401 14401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14402 14402 $as_echo "no" >&6; }
14403 14403 fi
14404 14404
14405 14405
14406 14406 test -n "$CYGPATH" && break
14407 14407 done
14408 14408
14409 14409 else
14410 14410 # If it succeeded, then it was overridden by the user. We will use it
14411 14411 # for the tool.
14412 14412
14413 14413 # First remove it from the list of overridden variables, so we can test
14414 14414 # for unknown variables in the end.
14415 14415 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14416 14416
14417 14417 # Check if we try to supply an empty value
14418 14418 if test "x$CYGPATH" = x; then
14419 14419 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
14420 14420 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
14421 14421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14422 14422 $as_echo_n "checking for CYGPATH... " >&6; }
14423 14423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14424 14424 $as_echo "disabled" >&6; }
14425 14425 else
14426 14426 # Check if the provided tool contains a complete path.
14427 14427 tool_specified="$CYGPATH"
14428 14428 tool_basename="${tool_specified##*/}"
14429 14429 if test "x$tool_basename" = "x$tool_specified"; then
14430 14430 # A command without a complete path is provided, search $PATH.
14431 14431 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
14432 14432 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
14433 14433 # Extract the first word of "$tool_basename", so it can be a program name with args.
14434 14434 set dummy $tool_basename; ac_word=$2
14435 14435 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14436 14436 $as_echo_n "checking for $ac_word... " >&6; }
14437 14437 if ${ac_cv_path_CYGPATH+:} false; then :
14438 14438 $as_echo_n "(cached) " >&6
14439 14439 else
14440 14440 case $CYGPATH in
14441 14441 [\\/]* | ?:[\\/]*)
14442 14442 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14443 14443 ;;
14444 14444 *)
14445 14445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14446 14446 for as_dir in $PATH
14447 14447 do
14448 14448 IFS=$as_save_IFS
14449 14449 test -z "$as_dir" && as_dir=.
14450 14450 for ac_exec_ext in '' $ac_executable_extensions; do
14451 14451 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14452 14452 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14453 14453 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14454 14454 break 2
14455 14455 fi
14456 14456 done
14457 14457 done
14458 14458 IFS=$as_save_IFS
14459 14459
14460 14460 ;;
14461 14461 esac
14462 14462 fi
14463 14463 CYGPATH=$ac_cv_path_CYGPATH
14464 14464 if test -n "$CYGPATH"; then
14465 14465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14466 14466 $as_echo "$CYGPATH" >&6; }
14467 14467 else
14468 14468 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14469 14469 $as_echo "no" >&6; }
14470 14470 fi
14471 14471
14472 14472
14473 14473 if test "x$CYGPATH" = x; then
14474 14474 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14475 14475 fi
14476 14476 else
14477 14477 # Otherwise we believe it is a complete path. Use it as it is.
14478 14478 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
14479 14479 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
14480 14480 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14481 14481 $as_echo_n "checking for CYGPATH... " >&6; }
14482 14482 if test ! -x "$tool_specified"; then
14483 14483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14484 14484 $as_echo "not found" >&6; }
14485 14485 as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
14486 14486 fi
14487 14487 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14488 14488 $as_echo "$tool_specified" >&6; }
14489 14489 fi
14490 14490 fi
14491 14491 fi
14492 14492
14493 14493 fi
14494 14494
14495 14495
14496 14496
14497 14497
14498 14498 # Publish this variable in the help.
14499 14499
14500 14500
14501 14501 if [ -z "${READLINK+x}" ]; then
14502 14502 # The variable is not set by user, try to locate tool using the code snippet
14503 14503 for ac_prog in greadlink readlink
14504 14504 do
14505 14505 # Extract the first word of "$ac_prog", so it can be a program name with args.
14506 14506 set dummy $ac_prog; ac_word=$2
14507 14507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14508 14508 $as_echo_n "checking for $ac_word... " >&6; }
14509 14509 if ${ac_cv_path_READLINK+:} false; then :
14510 14510 $as_echo_n "(cached) " >&6
14511 14511 else
14512 14512 case $READLINK in
14513 14513 [\\/]* | ?:[\\/]*)
14514 14514 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14515 14515 ;;
14516 14516 *)
14517 14517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14518 14518 for as_dir in $PATH
14519 14519 do
14520 14520 IFS=$as_save_IFS
14521 14521 test -z "$as_dir" && as_dir=.
14522 14522 for ac_exec_ext in '' $ac_executable_extensions; do
14523 14523 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14524 14524 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14525 14525 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14526 14526 break 2
14527 14527 fi
14528 14528 done
14529 14529 done
14530 14530 IFS=$as_save_IFS
14531 14531
14532 14532 ;;
14533 14533 esac
14534 14534 fi
14535 14535 READLINK=$ac_cv_path_READLINK
14536 14536 if test -n "$READLINK"; then
14537 14537 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14538 14538 $as_echo "$READLINK" >&6; }
14539 14539 else
14540 14540 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14541 14541 $as_echo "no" >&6; }
14542 14542 fi
14543 14543
14544 14544
14545 14545 test -n "$READLINK" && break
14546 14546 done
14547 14547
14548 14548 else
14549 14549 # The variable is set, but is it from the command line or the environment?
14550 14550
14551 14551 # Try to remove the string !READLINK! from our list.
14552 14552 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
14553 14553 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14554 14554 # If it failed, the variable was not from the command line. Ignore it,
14555 14555 # but warn the user (except for BASH, which is always set by the calling BASH).
14556 14556 if test "xREADLINK" != xBASH; then
14557 14557 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
14558 14558 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
14559 14559 fi
14560 14560 # Try to locate tool using the code snippet
14561 14561 for ac_prog in greadlink readlink
14562 14562 do
14563 14563 # Extract the first word of "$ac_prog", so it can be a program name with args.
14564 14564 set dummy $ac_prog; ac_word=$2
14565 14565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14566 14566 $as_echo_n "checking for $ac_word... " >&6; }
14567 14567 if ${ac_cv_path_READLINK+:} false; then :
14568 14568 $as_echo_n "(cached) " >&6
14569 14569 else
14570 14570 case $READLINK in
14571 14571 [\\/]* | ?:[\\/]*)
14572 14572 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14573 14573 ;;
14574 14574 *)
14575 14575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14576 14576 for as_dir in $PATH
14577 14577 do
14578 14578 IFS=$as_save_IFS
14579 14579 test -z "$as_dir" && as_dir=.
14580 14580 for ac_exec_ext in '' $ac_executable_extensions; do
14581 14581 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14582 14582 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14583 14583 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14584 14584 break 2
14585 14585 fi
14586 14586 done
14587 14587 done
14588 14588 IFS=$as_save_IFS
14589 14589
14590 14590 ;;
14591 14591 esac
14592 14592 fi
14593 14593 READLINK=$ac_cv_path_READLINK
14594 14594 if test -n "$READLINK"; then
14595 14595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14596 14596 $as_echo "$READLINK" >&6; }
14597 14597 else
14598 14598 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14599 14599 $as_echo "no" >&6; }
14600 14600 fi
14601 14601
14602 14602
14603 14603 test -n "$READLINK" && break
14604 14604 done
14605 14605
14606 14606 else
14607 14607 # If it succeeded, then it was overridden by the user. We will use it
14608 14608 # for the tool.
14609 14609
14610 14610 # First remove it from the list of overridden variables, so we can test
14611 14611 # for unknown variables in the end.
14612 14612 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14613 14613
14614 14614 # Check if we try to supply an empty value
14615 14615 if test "x$READLINK" = x; then
14616 14616 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
14617 14617 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
14618 14618 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14619 14619 $as_echo_n "checking for READLINK... " >&6; }
14620 14620 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14621 14621 $as_echo "disabled" >&6; }
14622 14622 else
14623 14623 # Check if the provided tool contains a complete path.
14624 14624 tool_specified="$READLINK"
14625 14625 tool_basename="${tool_specified##*/}"
14626 14626 if test "x$tool_basename" = "x$tool_specified"; then
14627 14627 # A command without a complete path is provided, search $PATH.
14628 14628 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
14629 14629 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
14630 14630 # Extract the first word of "$tool_basename", so it can be a program name with args.
14631 14631 set dummy $tool_basename; ac_word=$2
14632 14632 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14633 14633 $as_echo_n "checking for $ac_word... " >&6; }
14634 14634 if ${ac_cv_path_READLINK+:} false; then :
14635 14635 $as_echo_n "(cached) " >&6
14636 14636 else
14637 14637 case $READLINK in
14638 14638 [\\/]* | ?:[\\/]*)
14639 14639 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14640 14640 ;;
14641 14641 *)
14642 14642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14643 14643 for as_dir in $PATH
14644 14644 do
14645 14645 IFS=$as_save_IFS
14646 14646 test -z "$as_dir" && as_dir=.
14647 14647 for ac_exec_ext in '' $ac_executable_extensions; do
14648 14648 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14649 14649 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14650 14650 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14651 14651 break 2
14652 14652 fi
14653 14653 done
14654 14654 done
14655 14655 IFS=$as_save_IFS
14656 14656
14657 14657 ;;
14658 14658 esac
14659 14659 fi
14660 14660 READLINK=$ac_cv_path_READLINK
14661 14661 if test -n "$READLINK"; then
14662 14662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14663 14663 $as_echo "$READLINK" >&6; }
14664 14664 else
14665 14665 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14666 14666 $as_echo "no" >&6; }
14667 14667 fi
14668 14668
14669 14669
14670 14670 if test "x$READLINK" = x; then
14671 14671 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14672 14672 fi
14673 14673 else
14674 14674 # Otherwise we believe it is a complete path. Use it as it is.
14675 14675 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
14676 14676 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
14677 14677 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14678 14678 $as_echo_n "checking for READLINK... " >&6; }
14679 14679 if test ! -x "$tool_specified"; then
14680 14680 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14681 14681 $as_echo "not found" >&6; }
14682 14682 as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
14683 14683 fi
14684 14684 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14685 14685 $as_echo "$tool_specified" >&6; }
14686 14686 fi
14687 14687 fi
14688 14688 fi
14689 14689
14690 14690 fi
14691 14691
14692 14692
14693 14693
14694 14694
14695 14695 # Publish this variable in the help.
14696 14696
14697 14697
14698 14698 if [ -z "${DF+x}" ]; then
14699 14699 # The variable is not set by user, try to locate tool using the code snippet
14700 14700 for ac_prog in df
14701 14701 do
14702 14702 # Extract the first word of "$ac_prog", so it can be a program name with args.
14703 14703 set dummy $ac_prog; ac_word=$2
14704 14704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14705 14705 $as_echo_n "checking for $ac_word... " >&6; }
14706 14706 if ${ac_cv_path_DF+:} false; then :
14707 14707 $as_echo_n "(cached) " >&6
14708 14708 else
14709 14709 case $DF in
14710 14710 [\\/]* | ?:[\\/]*)
14711 14711 ac_cv_path_DF="$DF" # Let the user override the test with a path.
14712 14712 ;;
14713 14713 *)
14714 14714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14715 14715 for as_dir in $PATH
14716 14716 do
14717 14717 IFS=$as_save_IFS
14718 14718 test -z "$as_dir" && as_dir=.
14719 14719 for ac_exec_ext in '' $ac_executable_extensions; do
14720 14720 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14721 14721 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14722 14722 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14723 14723 break 2
14724 14724 fi
14725 14725 done
14726 14726 done
14727 14727 IFS=$as_save_IFS
14728 14728
14729 14729 ;;
14730 14730 esac
14731 14731 fi
14732 14732 DF=$ac_cv_path_DF
14733 14733 if test -n "$DF"; then
14734 14734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14735 14735 $as_echo "$DF" >&6; }
14736 14736 else
14737 14737 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14738 14738 $as_echo "no" >&6; }
14739 14739 fi
14740 14740
14741 14741
14742 14742 test -n "$DF" && break
14743 14743 done
14744 14744
14745 14745 else
14746 14746 # The variable is set, but is it from the command line or the environment?
14747 14747
14748 14748 # Try to remove the string !DF! from our list.
14749 14749 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
14750 14750 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14751 14751 # If it failed, the variable was not from the command line. Ignore it,
14752 14752 # but warn the user (except for BASH, which is always set by the calling BASH).
14753 14753 if test "xDF" != xBASH; then
14754 14754 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
14755 14755 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
14756 14756 fi
14757 14757 # Try to locate tool using the code snippet
14758 14758 for ac_prog in df
14759 14759 do
14760 14760 # Extract the first word of "$ac_prog", so it can be a program name with args.
14761 14761 set dummy $ac_prog; ac_word=$2
14762 14762 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14763 14763 $as_echo_n "checking for $ac_word... " >&6; }
14764 14764 if ${ac_cv_path_DF+:} false; then :
14765 14765 $as_echo_n "(cached) " >&6
14766 14766 else
14767 14767 case $DF in
14768 14768 [\\/]* | ?:[\\/]*)
14769 14769 ac_cv_path_DF="$DF" # Let the user override the test with a path.
14770 14770 ;;
14771 14771 *)
14772 14772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14773 14773 for as_dir in $PATH
14774 14774 do
14775 14775 IFS=$as_save_IFS
14776 14776 test -z "$as_dir" && as_dir=.
14777 14777 for ac_exec_ext in '' $ac_executable_extensions; do
14778 14778 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14779 14779 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14780 14780 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14781 14781 break 2
14782 14782 fi
14783 14783 done
14784 14784 done
14785 14785 IFS=$as_save_IFS
14786 14786
14787 14787 ;;
14788 14788 esac
14789 14789 fi
14790 14790 DF=$ac_cv_path_DF
14791 14791 if test -n "$DF"; then
14792 14792 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14793 14793 $as_echo "$DF" >&6; }
14794 14794 else
14795 14795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14796 14796 $as_echo "no" >&6; }
14797 14797 fi
14798 14798
14799 14799
14800 14800 test -n "$DF" && break
14801 14801 done
14802 14802
14803 14803 else
14804 14804 # If it succeeded, then it was overridden by the user. We will use it
14805 14805 # for the tool.
14806 14806
14807 14807 # First remove it from the list of overridden variables, so we can test
14808 14808 # for unknown variables in the end.
14809 14809 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14810 14810
14811 14811 # Check if we try to supply an empty value
14812 14812 if test "x$DF" = x; then
14813 14813 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14814 14814 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14815 14815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14816 14816 $as_echo_n "checking for DF... " >&6; }
14817 14817 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14818 14818 $as_echo "disabled" >&6; }
14819 14819 else
14820 14820 # Check if the provided tool contains a complete path.
14821 14821 tool_specified="$DF"
14822 14822 tool_basename="${tool_specified##*/}"
14823 14823 if test "x$tool_basename" = "x$tool_specified"; then
14824 14824 # A command without a complete path is provided, search $PATH.
14825 14825 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14826 14826 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14827 14827 # Extract the first word of "$tool_basename", so it can be a program name with args.
14828 14828 set dummy $tool_basename; ac_word=$2
14829 14829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14830 14830 $as_echo_n "checking for $ac_word... " >&6; }
14831 14831 if ${ac_cv_path_DF+:} false; then :
14832 14832 $as_echo_n "(cached) " >&6
14833 14833 else
14834 14834 case $DF in
14835 14835 [\\/]* | ?:[\\/]*)
14836 14836 ac_cv_path_DF="$DF" # Let the user override the test with a path.
14837 14837 ;;
14838 14838 *)
14839 14839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14840 14840 for as_dir in $PATH
14841 14841 do
14842 14842 IFS=$as_save_IFS
14843 14843 test -z "$as_dir" && as_dir=.
14844 14844 for ac_exec_ext in '' $ac_executable_extensions; do
14845 14845 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14846 14846 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14847 14847 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14848 14848 break 2
14849 14849 fi
14850 14850 done
14851 14851 done
14852 14852 IFS=$as_save_IFS
14853 14853
14854 14854 ;;
14855 14855 esac
14856 14856 fi
14857 14857 DF=$ac_cv_path_DF
14858 14858 if test -n "$DF"; then
14859 14859 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14860 14860 $as_echo "$DF" >&6; }
14861 14861 else
14862 14862 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14863 14863 $as_echo "no" >&6; }
14864 14864 fi
14865 14865
14866 14866
14867 14867 if test "x$DF" = x; then
14868 14868 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14869 14869 fi
14870 14870 else
14871 14871 # Otherwise we believe it is a complete path. Use it as it is.
14872 14872 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14873 14873 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14874 14874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14875 14875 $as_echo_n "checking for DF... " >&6; }
14876 14876 if test ! -x "$tool_specified"; then
14877 14877 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14878 14878 $as_echo "not found" >&6; }
14879 14879 as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14880 14880 fi
14881 14881 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14882 14882 $as_echo "$tool_specified" >&6; }
14883 14883 fi
14884 14884 fi
14885 14885 fi
14886 14886
14887 14887 fi
14888 14888
14889 14889
14890 14890
14891 14891
14892 14892 # Publish this variable in the help.
14893 14893
14894 14894
14895 14895 if [ -z "${CPIO+x}" ]; then
14896 14896 # The variable is not set by user, try to locate tool using the code snippet
14897 14897 for ac_prog in cpio bsdcpio
14898 14898 do
14899 14899 # Extract the first word of "$ac_prog", so it can be a program name with args.
14900 14900 set dummy $ac_prog; ac_word=$2
14901 14901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14902 14902 $as_echo_n "checking for $ac_word... " >&6; }
14903 14903 if ${ac_cv_path_CPIO+:} false; then :
14904 14904 $as_echo_n "(cached) " >&6
14905 14905 else
14906 14906 case $CPIO in
14907 14907 [\\/]* | ?:[\\/]*)
14908 14908 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14909 14909 ;;
14910 14910 *)
14911 14911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14912 14912 for as_dir in $PATH
14913 14913 do
14914 14914 IFS=$as_save_IFS
14915 14915 test -z "$as_dir" && as_dir=.
14916 14916 for ac_exec_ext in '' $ac_executable_extensions; do
14917 14917 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14918 14918 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14919 14919 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14920 14920 break 2
14921 14921 fi
14922 14922 done
14923 14923 done
14924 14924 IFS=$as_save_IFS
14925 14925
14926 14926 ;;
14927 14927 esac
14928 14928 fi
14929 14929 CPIO=$ac_cv_path_CPIO
14930 14930 if test -n "$CPIO"; then
14931 14931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14932 14932 $as_echo "$CPIO" >&6; }
14933 14933 else
14934 14934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14935 14935 $as_echo "no" >&6; }
14936 14936 fi
14937 14937
14938 14938
14939 14939 test -n "$CPIO" && break
14940 14940 done
14941 14941
14942 14942 else
14943 14943 # The variable is set, but is it from the command line or the environment?
14944 14944
14945 14945 # Try to remove the string !CPIO! from our list.
14946 14946 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14947 14947 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14948 14948 # If it failed, the variable was not from the command line. Ignore it,
14949 14949 # but warn the user (except for BASH, which is always set by the calling BASH).
14950 14950 if test "xCPIO" != xBASH; then
14951 14951 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14952 14952 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14953 14953 fi
14954 14954 # Try to locate tool using the code snippet
14955 14955 for ac_prog in cpio bsdcpio
14956 14956 do
14957 14957 # Extract the first word of "$ac_prog", so it can be a program name with args.
14958 14958 set dummy $ac_prog; ac_word=$2
14959 14959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14960 14960 $as_echo_n "checking for $ac_word... " >&6; }
14961 14961 if ${ac_cv_path_CPIO+:} false; then :
14962 14962 $as_echo_n "(cached) " >&6
14963 14963 else
14964 14964 case $CPIO in
14965 14965 [\\/]* | ?:[\\/]*)
14966 14966 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14967 14967 ;;
14968 14968 *)
14969 14969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14970 14970 for as_dir in $PATH
14971 14971 do
14972 14972 IFS=$as_save_IFS
14973 14973 test -z "$as_dir" && as_dir=.
14974 14974 for ac_exec_ext in '' $ac_executable_extensions; do
14975 14975 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14976 14976 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14977 14977 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14978 14978 break 2
14979 14979 fi
14980 14980 done
14981 14981 done
14982 14982 IFS=$as_save_IFS
14983 14983
14984 14984 ;;
14985 14985 esac
14986 14986 fi
14987 14987 CPIO=$ac_cv_path_CPIO
14988 14988 if test -n "$CPIO"; then
14989 14989 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14990 14990 $as_echo "$CPIO" >&6; }
14991 14991 else
14992 14992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14993 14993 $as_echo "no" >&6; }
14994 14994 fi
14995 14995
14996 14996
14997 14997 test -n "$CPIO" && break
14998 14998 done
14999 14999
15000 15000 else
15001 15001 # If it succeeded, then it was overridden by the user. We will use it
15002 15002 # for the tool.
15003 15003
15004 15004 # First remove it from the list of overridden variables, so we can test
15005 15005 # for unknown variables in the end.
15006 15006 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15007 15007
15008 15008 # Check if we try to supply an empty value
15009 15009 if test "x$CPIO" = x; then
15010 15010 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
15011 15011 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
15012 15012 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15013 15013 $as_echo_n "checking for CPIO... " >&6; }
15014 15014 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15015 15015 $as_echo "disabled" >&6; }
15016 15016 else
15017 15017 # Check if the provided tool contains a complete path.
15018 15018 tool_specified="$CPIO"
15019 15019 tool_basename="${tool_specified##*/}"
15020 15020 if test "x$tool_basename" = "x$tool_specified"; then
15021 15021 # A command without a complete path is provided, search $PATH.
15022 15022 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
15023 15023 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
15024 15024 # Extract the first word of "$tool_basename", so it can be a program name with args.
15025 15025 set dummy $tool_basename; ac_word=$2
15026 15026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15027 15027 $as_echo_n "checking for $ac_word... " >&6; }
15028 15028 if ${ac_cv_path_CPIO+:} false; then :
15029 15029 $as_echo_n "(cached) " >&6
15030 15030 else
15031 15031 case $CPIO in
15032 15032 [\\/]* | ?:[\\/]*)
15033 15033 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
15034 15034 ;;
15035 15035 *)
15036 15036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15037 15037 for as_dir in $PATH
15038 15038 do
15039 15039 IFS=$as_save_IFS
15040 15040 test -z "$as_dir" && as_dir=.
15041 15041 for ac_exec_ext in '' $ac_executable_extensions; do
15042 15042 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15043 15043 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
15044 15044 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15045 15045 break 2
15046 15046 fi
15047 15047 done
15048 15048 done
15049 15049 IFS=$as_save_IFS
15050 15050
15051 15051 ;;
15052 15052 esac
15053 15053 fi
15054 15054 CPIO=$ac_cv_path_CPIO
15055 15055 if test -n "$CPIO"; then
15056 15056 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
15057 15057 $as_echo "$CPIO" >&6; }
15058 15058 else
15059 15059 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15060 15060 $as_echo "no" >&6; }
15061 15061 fi
15062 15062
15063 15063
15064 15064 if test "x$CPIO" = x; then
15065 15065 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15066 15066 fi
15067 15067 else
15068 15068 # Otherwise we believe it is a complete path. Use it as it is.
15069 15069 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
15070 15070 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
15071 15071 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15072 15072 $as_echo_n "checking for CPIO... " >&6; }
15073 15073 if test ! -x "$tool_specified"; then
15074 15074 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15075 15075 $as_echo "not found" >&6; }
15076 15076 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
15077 15077 fi
15078 15078 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15079 15079 $as_echo "$tool_specified" >&6; }
15080 15080 fi
15081 15081 fi
15082 15082 fi
15083 15083
15084 15084 fi
15085 15085
15086 15086
15087 15087
15088 15088
15089 15089 # Publish this variable in the help.
15090 15090
15091 15091
15092 15092 if [ -z "${NICE+x}" ]; then
15093 15093 # The variable is not set by user, try to locate tool using the code snippet
15094 15094 for ac_prog in nice
15095 15095 do
15096 15096 # Extract the first word of "$ac_prog", so it can be a program name with args.
15097 15097 set dummy $ac_prog; ac_word=$2
15098 15098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15099 15099 $as_echo_n "checking for $ac_word... " >&6; }
15100 15100 if ${ac_cv_path_NICE+:} false; then :
15101 15101 $as_echo_n "(cached) " >&6
15102 15102 else
15103 15103 case $NICE in
15104 15104 [\\/]* | ?:[\\/]*)
15105 15105 ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15106 15106 ;;
15107 15107 *)
15108 15108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15109 15109 for as_dir in $PATH
15110 15110 do
15111 15111 IFS=$as_save_IFS
15112 15112 test -z "$as_dir" && as_dir=.
15113 15113 for ac_exec_ext in '' $ac_executable_extensions; do
15114 15114 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15115 15115 ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15116 15116 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15117 15117 break 2
15118 15118 fi
15119 15119 done
15120 15120 done
15121 15121 IFS=$as_save_IFS
15122 15122
15123 15123 ;;
15124 15124 esac
15125 15125 fi
15126 15126 NICE=$ac_cv_path_NICE
15127 15127 if test -n "$NICE"; then
15128 15128 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15129 15129 $as_echo "$NICE" >&6; }
15130 15130 else
15131 15131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15132 15132 $as_echo "no" >&6; }
15133 15133 fi
15134 15134
15135 15135
15136 15136 test -n "$NICE" && break
15137 15137 done
15138 15138
15139 15139 else
15140 15140 # The variable is set, but is it from the command line or the environment?
15141 15141
15142 15142 # Try to remove the string !NICE! from our list.
15143 15143 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
15144 15144 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
15145 15145 # If it failed, the variable was not from the command line. Ignore it,
15146 15146 # but warn the user (except for BASH, which is always set by the calling BASH).
15147 15147 if test "xNICE" != xBASH; then
15148 15148 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
15149 15149 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
15150 15150 fi
15151 15151 # Try to locate tool using the code snippet
15152 15152 for ac_prog in nice
15153 15153 do
15154 15154 # Extract the first word of "$ac_prog", so it can be a program name with args.
15155 15155 set dummy $ac_prog; ac_word=$2
15156 15156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15157 15157 $as_echo_n "checking for $ac_word... " >&6; }
15158 15158 if ${ac_cv_path_NICE+:} false; then :
15159 15159 $as_echo_n "(cached) " >&6
15160 15160 else
15161 15161 case $NICE in
15162 15162 [\\/]* | ?:[\\/]*)
15163 15163 ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15164 15164 ;;
15165 15165 *)
15166 15166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15167 15167 for as_dir in $PATH
15168 15168 do
15169 15169 IFS=$as_save_IFS
15170 15170 test -z "$as_dir" && as_dir=.
15171 15171 for ac_exec_ext in '' $ac_executable_extensions; do
15172 15172 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15173 15173 ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15174 15174 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15175 15175 break 2
15176 15176 fi
15177 15177 done
15178 15178 done
15179 15179 IFS=$as_save_IFS
15180 15180
15181 15181 ;;
15182 15182 esac
15183 15183 fi
15184 15184 NICE=$ac_cv_path_NICE
15185 15185 if test -n "$NICE"; then
15186 15186 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15187 15187 $as_echo "$NICE" >&6; }
15188 15188 else
15189 15189 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15190 15190 $as_echo "no" >&6; }
15191 15191 fi
15192 15192
15193 15193
15194 15194 test -n "$NICE" && break
15195 15195 done
15196 15196
15197 15197 else
15198 15198 # If it succeeded, then it was overridden by the user. We will use it
15199 15199 # for the tool.
15200 15200
15201 15201 # First remove it from the list of overridden variables, so we can test
15202 15202 # for unknown variables in the end.
15203 15203 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15204 15204
15205 15205 # Check if we try to supply an empty value
15206 15206 if test "x$NICE" = x; then
15207 15207 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
15208 15208 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
15209 15209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15210 15210 $as_echo_n "checking for NICE... " >&6; }
15211 15211 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15212 15212 $as_echo "disabled" >&6; }
15213 15213 else
15214 15214 # Check if the provided tool contains a complete path.
15215 15215 tool_specified="$NICE"
15216 15216 tool_basename="${tool_specified##*/}"
15217 15217 if test "x$tool_basename" = "x$tool_specified"; then
15218 15218 # A command without a complete path is provided, search $PATH.
15219 15219 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
15220 15220 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
15221 15221 # Extract the first word of "$tool_basename", so it can be a program name with args.
15222 15222 set dummy $tool_basename; ac_word=$2
15223 15223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15224 15224 $as_echo_n "checking for $ac_word... " >&6; }
15225 15225 if ${ac_cv_path_NICE+:} false; then :
15226 15226 $as_echo_n "(cached) " >&6
15227 15227 else
15228 15228 case $NICE in
15229 15229 [\\/]* | ?:[\\/]*)
15230 15230 ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15231 15231 ;;
15232 15232 *)
15233 15233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15234 15234 for as_dir in $PATH
15235 15235 do
15236 15236 IFS=$as_save_IFS
15237 15237 test -z "$as_dir" && as_dir=.
15238 15238 for ac_exec_ext in '' $ac_executable_extensions; do
15239 15239 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15240 15240 ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15241 15241 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15242 15242 break 2
15243 15243 fi
15244 15244 done
15245 15245 done
15246 15246 IFS=$as_save_IFS
15247 15247
15248 15248 ;;
15249 15249 esac
15250 15250 fi
15251 15251 NICE=$ac_cv_path_NICE
15252 15252 if test -n "$NICE"; then
15253 15253 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15254 15254 $as_echo "$NICE" >&6; }
15255 15255 else
15256 15256 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15257 15257 $as_echo "no" >&6; }
15258 15258 fi
15259 15259
15260 15260
15261 15261 if test "x$NICE" = x; then
15262 15262 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15263 15263 fi
15264 15264 else
15265 15265 # Otherwise we believe it is a complete path. Use it as it is.
15266 15266 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
15267 15267 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
15268 15268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15269 15269 $as_echo_n "checking for NICE... " >&6; }
15270 15270 if test ! -x "$tool_specified"; then
15271 15271 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15272 15272 $as_echo "not found" >&6; }
15273 15273 as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
15274 15274 fi
15275 15275 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15276 15276 $as_echo "$tool_specified" >&6; }
15277 15277 fi
15278 15278 fi
15279 15279 fi
15280 15280
15281 15281 fi
15282 15282
15283 15283
15284 15284
15285 15285
15286 15286 # Now we can determine OpenJDK build and target platforms. This is required to
15287 15287 # have early on.
15288 15288 # Make sure we can run config.sub.
15289 15289 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
15290 15290 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
15291 15291
15292 15292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
15293 15293 $as_echo_n "checking build system type... " >&6; }
15294 15294 if ${ac_cv_build+:} false; then :
15295 15295 $as_echo_n "(cached) " >&6
15296 15296 else
15297 15297 ac_build_alias=$build_alias
15298 15298 test "x$ac_build_alias" = x &&
15299 15299 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
15300 15300 test "x$ac_build_alias" = x &&
15301 15301 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
15302 15302 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
15303 15303 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
15304 15304
15305 15305 fi
15306 15306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
15307 15307 $as_echo "$ac_cv_build" >&6; }
15308 15308 case $ac_cv_build in
15309 15309 *-*-*) ;;
15310 15310 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
15311 15311 esac
15312 15312 build=$ac_cv_build
15313 15313 ac_save_IFS=$IFS; IFS='-'
15314 15314 set x $ac_cv_build
15315 15315 shift
15316 15316 build_cpu=$1
15317 15317 build_vendor=$2
15318 15318 shift; shift
15319 15319 # Remember, the first character of IFS is used to create $*,
15320 15320 # except with old shells:
15321 15321 build_os=$*
15322 15322 IFS=$ac_save_IFS
15323 15323 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
15324 15324
15325 15325
15326 15326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
15327 15327 $as_echo_n "checking host system type... " >&6; }
15328 15328 if ${ac_cv_host+:} false; then :
15329 15329 $as_echo_n "(cached) " >&6
15330 15330 else
15331 15331 if test "x$host_alias" = x; then
15332 15332 ac_cv_host=$ac_cv_build
15333 15333 else
15334 15334 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
15335 15335 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
15336 15336 fi
15337 15337
15338 15338 fi
15339 15339 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
15340 15340 $as_echo "$ac_cv_host" >&6; }
15341 15341 case $ac_cv_host in
15342 15342 *-*-*) ;;
15343 15343 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
15344 15344 esac
15345 15345 host=$ac_cv_host
15346 15346 ac_save_IFS=$IFS; IFS='-'
15347 15347 set x $ac_cv_host
15348 15348 shift
15349 15349 host_cpu=$1
15350 15350 host_vendor=$2
15351 15351 shift; shift
15352 15352 # Remember, the first character of IFS is used to create $*,
15353 15353 # except with old shells:
15354 15354 host_os=$*
15355 15355 IFS=$ac_save_IFS
15356 15356 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
15357 15357
15358 15358
15359 15359 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
15360 15360 $as_echo_n "checking target system type... " >&6; }
15361 15361 if ${ac_cv_target+:} false; then :
15362 15362 $as_echo_n "(cached) " >&6
15363 15363 else
15364 15364 if test "x$target_alias" = x; then
15365 15365 ac_cv_target=$ac_cv_host
15366 15366 else
15367 15367 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
15368 15368 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
15369 15369 fi
15370 15370
15371 15371 fi
15372 15372 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
15373 15373 $as_echo "$ac_cv_target" >&6; }
15374 15374 case $ac_cv_target in
15375 15375 *-*-*) ;;
15376 15376 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
15377 15377 esac
15378 15378 target=$ac_cv_target
15379 15379 ac_save_IFS=$IFS; IFS='-'
15380 15380 set x $ac_cv_target
15381 15381 shift
15382 15382 target_cpu=$1
15383 15383 target_vendor=$2
15384 15384 shift; shift
15385 15385 # Remember, the first character of IFS is used to create $*,
15386 15386 # except with old shells:
15387 15387 target_os=$*
15388 15388 IFS=$ac_save_IFS
15389 15389 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
15390 15390
15391 15391
15392 15392 # The aliases save the names the user supplied, while $host etc.
15393 15393 # will get canonicalized.
15394 15394 test -n "$target_alias" &&
15395 15395 test "$program_prefix$program_suffix$program_transform_name" = \
15396 15396 NONENONEs,x,x, &&
15397 15397 program_prefix=${target_alias}-
15398 15398
15399 15399 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
15400 15400 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
15401 15401 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
15402 15402 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
15403 15403 # to use the configure naming style.
15404 15404
15405 15405
15406 15406
15407 15407
15408 15408
15409 15409 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
15410 15410 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
15411 15411 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
15412 15412 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
15413 15413 OPENJDK_TARGET_AUTOCONF_NAME="$host"
15414 15414 OPENJDK_BUILD_AUTOCONF_NAME="$build"
15415 15415
15416 15416
15417 15417
15418 15418 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15419 15419
15420 15420 case "$build_os" in
15421 15421 *linux*)
15422 15422 VAR_OS=linux
15423 15423 VAR_OS_TYPE=unix
15424 15424 ;;
15425 15425 *solaris*)
15426 15426 VAR_OS=solaris
15427 15427 VAR_OS_TYPE=unix
15428 15428 ;;
15429 15429 *darwin*)
15430 15430 VAR_OS=macosx
15431 15431 VAR_OS_TYPE=unix
15432 15432 ;;
15433 15433 *bsd*)
15434 15434 VAR_OS=bsd
15435 15435 VAR_OS_TYPE=unix
15436 15436 ;;
15437 15437 *cygwin*)
15438 15438 VAR_OS=windows
15439 15439 VAR_OS_ENV=windows.cygwin
15440 15440 ;;
15441 15441 *mingw*)
15442 15442 VAR_OS=windows
15443 15443 VAR_OS_ENV=windows.msys
15444 15444 ;;
15445 15445 *aix*)
15446 15446 VAR_OS=aix
15447 15447 VAR_OS_TYPE=unix
15448 15448 ;;
15449 15449 *)
15450 15450 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
15451 15451 ;;
15452 15452 esac
15453 15453
15454 15454
15455 15455 # First argument is the cpu name from the trip/quad
15456 15456 case "$build_cpu" in
15457 15457 x86_64)
15458 15458 VAR_CPU=x86_64
15459 15459 VAR_CPU_ARCH=x86
15460 15460 VAR_CPU_BITS=64
15461 15461 VAR_CPU_ENDIAN=little
15462 15462 ;;
15463 15463 i?86)
15464 15464 VAR_CPU=x86
15465 15465 VAR_CPU_ARCH=x86
15466 15466 VAR_CPU_BITS=32
15467 15467 VAR_CPU_ENDIAN=little
15468 15468 ;;
15469 15469 arm*)
15470 15470 VAR_CPU=arm
15471 15471 VAR_CPU_ARCH=arm
15472 15472 VAR_CPU_BITS=32
15473 15473 VAR_CPU_ENDIAN=little
15474 15474 ;;
15475 15475 aarch64)
15476 15476 VAR_CPU=aarch64
15477 15477 VAR_CPU_ARCH=aarch64
15478 15478 VAR_CPU_BITS=64
15479 15479 VAR_CPU_ENDIAN=little
15480 15480 ;;
15481 15481 powerpc)
15482 15482 VAR_CPU=ppc
15483 15483 VAR_CPU_ARCH=ppc
15484 15484 VAR_CPU_BITS=32
15485 15485 VAR_CPU_ENDIAN=big
15486 15486 ;;
15487 15487 powerpc64)
15488 15488 VAR_CPU=ppc64
15489 15489 VAR_CPU_ARCH=ppc
15490 15490 VAR_CPU_BITS=64
15491 15491 VAR_CPU_ENDIAN=big
15492 15492 ;;
15493 15493 powerpc64le)
15494 15494 VAR_CPU=ppc64le
15495 15495 VAR_CPU_ARCH=ppc
15496 15496 VAR_CPU_BITS=64
15497 15497 VAR_CPU_ENDIAN=little
15498 15498 ;;
15499 15499 s390)
15500 15500 VAR_CPU=s390
15501 15501 VAR_CPU_ARCH=s390
15502 15502 VAR_CPU_BITS=32
15503 15503 VAR_CPU_ENDIAN=big
15504 15504 ;;
15505 15505 s390x)
15506 15506 VAR_CPU=s390x
15507 15507 VAR_CPU_ARCH=s390
15508 15508 VAR_CPU_BITS=64
15509 15509 VAR_CPU_ENDIAN=big
15510 15510 ;;
15511 15511 sparc)
15512 15512 VAR_CPU=sparc
15513 15513 VAR_CPU_ARCH=sparc
15514 15514 VAR_CPU_BITS=32
15515 15515 VAR_CPU_ENDIAN=big
15516 15516 ;;
15517 15517 sparcv9|sparc64)
15518 15518 VAR_CPU=sparcv9
15519 15519 VAR_CPU_ARCH=sparc
15520 15520 VAR_CPU_BITS=64
15521 15521 VAR_CPU_ENDIAN=big
15522 15522 ;;
15523 15523 *)
15524 15524 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
15525 15525 ;;
15526 15526 esac
15527 15527
15528 15528 # ..and setup our own variables. (Do this explicitely to facilitate searching)
15529 15529 OPENJDK_BUILD_OS="$VAR_OS"
15530 15530 if test "x$VAR_OS_TYPE" != x; then
15531 15531 OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
15532 15532 else
15533 15533 OPENJDK_BUILD_OS_TYPE="$VAR_OS"
15534 15534 fi
15535 15535 if test "x$VAR_OS_ENV" != x; then
15536 15536 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
15537 15537 else
15538 15538 OPENJDK_BUILD_OS_ENV="$VAR_OS"
15539 15539 fi
15540 15540 OPENJDK_BUILD_CPU="$VAR_CPU"
15541 15541 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
15542 15542 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
15543 15543 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15544 15544
15545 15545
15546 15546
15547 15547
15548 15548
15549 15549
15550 15550
15551 15551
15552 15552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
15553 15553 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
15554 15554 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
15555 15555 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
15556 15556
15557 15557 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15558 15558
15559 15559 case "$host_os" in
15560 15560 *linux*)
15561 15561 VAR_OS=linux
15562 15562 VAR_OS_TYPE=unix
15563 15563 ;;
15564 15564 *solaris*)
15565 15565 VAR_OS=solaris
15566 15566 VAR_OS_TYPE=unix
15567 15567 ;;
15568 15568 *darwin*)
15569 15569 VAR_OS=macosx
15570 15570 VAR_OS_TYPE=unix
15571 15571 ;;
15572 15572 *bsd*)
15573 15573 VAR_OS=bsd
15574 15574 VAR_OS_TYPE=unix
15575 15575 ;;
15576 15576 *cygwin*)
15577 15577 VAR_OS=windows
15578 15578 VAR_OS_ENV=windows.cygwin
15579 15579 ;;
15580 15580 *mingw*)
15581 15581 VAR_OS=windows
15582 15582 VAR_OS_ENV=windows.msys
15583 15583 ;;
15584 15584 *aix*)
15585 15585 VAR_OS=aix
15586 15586 VAR_OS_TYPE=unix
15587 15587 ;;
15588 15588 *)
15589 15589 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
15590 15590 ;;
15591 15591 esac
15592 15592
15593 15593
15594 15594 # First argument is the cpu name from the trip/quad
15595 15595 case "$host_cpu" in
15596 15596 x86_64)
15597 15597 VAR_CPU=x86_64
15598 15598 VAR_CPU_ARCH=x86
15599 15599 VAR_CPU_BITS=64
15600 15600 VAR_CPU_ENDIAN=little
15601 15601 ;;
15602 15602 i?86)
15603 15603 VAR_CPU=x86
15604 15604 VAR_CPU_ARCH=x86
15605 15605 VAR_CPU_BITS=32
15606 15606 VAR_CPU_ENDIAN=little
15607 15607 ;;
15608 15608 arm*)
15609 15609 VAR_CPU=arm
15610 15610 VAR_CPU_ARCH=arm
15611 15611 VAR_CPU_BITS=32
15612 15612 VAR_CPU_ENDIAN=little
15613 15613 ;;
15614 15614 aarch64)
15615 15615 VAR_CPU=aarch64
15616 15616 VAR_CPU_ARCH=aarch64
15617 15617 VAR_CPU_BITS=64
15618 15618 VAR_CPU_ENDIAN=little
15619 15619 ;;
15620 15620 powerpc)
15621 15621 VAR_CPU=ppc
15622 15622 VAR_CPU_ARCH=ppc
15623 15623 VAR_CPU_BITS=32
15624 15624 VAR_CPU_ENDIAN=big
15625 15625 ;;
15626 15626 powerpc64)
15627 15627 VAR_CPU=ppc64
15628 15628 VAR_CPU_ARCH=ppc
15629 15629 VAR_CPU_BITS=64
15630 15630 VAR_CPU_ENDIAN=big
15631 15631 ;;
15632 15632 powerpc64le)
15633 15633 VAR_CPU=ppc64le
15634 15634 VAR_CPU_ARCH=ppc
15635 15635 VAR_CPU_BITS=64
15636 15636 VAR_CPU_ENDIAN=little
15637 15637 ;;
15638 15638 s390)
15639 15639 VAR_CPU=s390
15640 15640 VAR_CPU_ARCH=s390
15641 15641 VAR_CPU_BITS=32
15642 15642 VAR_CPU_ENDIAN=big
15643 15643 ;;
15644 15644 s390x)
15645 15645 VAR_CPU=s390x
15646 15646 VAR_CPU_ARCH=s390
15647 15647 VAR_CPU_BITS=64
15648 15648 VAR_CPU_ENDIAN=big
15649 15649 ;;
15650 15650 sparc)
15651 15651 VAR_CPU=sparc
15652 15652 VAR_CPU_ARCH=sparc
15653 15653 VAR_CPU_BITS=32
15654 15654 VAR_CPU_ENDIAN=big
15655 15655 ;;
15656 15656 sparcv9|sparc64)
15657 15657 VAR_CPU=sparcv9
15658 15658 VAR_CPU_ARCH=sparc
15659 15659 VAR_CPU_BITS=64
15660 15660 VAR_CPU_ENDIAN=big
15661 15661 ;;
15662 15662 *)
15663 15663 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
15664 15664 ;;
15665 15665 esac
15666 15666
15667 15667 # ... and setup our own variables. (Do this explicitely to facilitate searching)
15668 15668 OPENJDK_TARGET_OS="$VAR_OS"
15669 15669 if test "x$VAR_OS_TYPE" != x; then
15670 15670 OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
15671 15671 else
15672 15672 OPENJDK_TARGET_OS_TYPE="$VAR_OS"
15673 15673 fi
15674 15674 if test "x$VAR_OS_ENV" != x; then
15675 15675 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
15676 15676 else
15677 15677 OPENJDK_TARGET_OS_ENV="$VAR_OS"
15678 15678 fi
15679 15679 OPENJDK_TARGET_CPU="$VAR_CPU"
15680 15680 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
15681 15681 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
15682 15682 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15683 15683
15684 15684
15685 15685
15686 15686
15687 15687
15688 15688
15689 15689
15690 15690
15691 15691 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
15692 15692 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
15693 15693 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
15694 15694 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
15695 15695
15696 15696
15697 15697
15698 15698 # Check whether --with-target-bits was given.
15699 15699 if test "${with_target_bits+set}" = set; then :
15700 15700 withval=$with_target_bits;
15701 15701 fi
15702 15702
15703 15703
15704 15704 # We have three types of compiles:
15705 15705 # native == normal compilation, target system == build system
15706 15706 # cross == traditional cross compilation, target system != build system; special toolchain needed
15707 15707 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
15708 15708 #
15709 15709 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
15710 15710 # We're doing a proper cross-compilation
15711 15711 COMPILE_TYPE="cross"
15712 15712 else
15713 15713 COMPILE_TYPE="native"
15714 15714 fi
15715 15715
15716 15716 if test "x$with_target_bits" != x; then
15717 15717 if test "x$COMPILE_TYPE" = "xcross"; then
15718 15718 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
15719 15719 fi
15720 15720
15721 15721 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15722 15722 # A reduced build is requested
15723 15723 COMPILE_TYPE="reduced"
15724 15724 OPENJDK_TARGET_CPU_BITS=32
15725 15725 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
15726 15726 OPENJDK_TARGET_CPU=x86
15727 15727 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
15728 15728 OPENJDK_TARGET_CPU=sparc
15729 15729 else
15730 15730 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
15731 15731 fi
15732 15732 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
15733 15733 as_fn_error $? "It is not possible to use --with-target-bits=64 on a 32 bit system. Use proper cross-compilation instead." "$LINENO" 5
15734 15734 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
15735 15735 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
15736 15736 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
15737 15737 else
15738 15738 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
15739 15739 fi
15740 15740 fi
15741 15741
15742 15742
15743 15743 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
15744 15744 $as_echo_n "checking compilation type... " >&6; }
15745 15745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
15746 15746 $as_echo "$COMPILE_TYPE" >&6; }
15747 15747
15748 15748
15749 15749 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
15750 15750 REQUIRED_OS_NAME=SunOS
15751 15751 REQUIRED_OS_VERSION=5.10
15752 15752 fi
15753 15753 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
15754 15754 REQUIRED_OS_NAME=Linux
15755 15755 REQUIRED_OS_VERSION=2.6
15756 15756 fi
15757 15757 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15758 15758 REQUIRED_OS_NAME=Windows
15759 15759 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
15760 15760 REQUIRED_OS_VERSION=5.2
15761 15761 else
15762 15762 REQUIRED_OS_VERSION=5.1
15763 15763 fi
15764 15764 fi
15765 15765 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15766 15766 REQUIRED_OS_NAME=Darwin
15767 15767 REQUIRED_OS_VERSION=11.2
15768 15768 fi
15769 15769 if test "x$OPENJDK_TARGET_OS" = "xaix"; then
15770 15770 REQUIRED_OS_NAME=AIX
15771 15771 REQUIRED_OS_VERSION=7.1
15772 15772 fi
15773 15773
15774 15774
15775 15775
15776 15776
15777 15777
15778 15778
15779 15779 # Also store the legacy naming of the cpu.
15780 15780 # Ie i586 and amd64 instead of x86 and x86_64
15781 15781 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
15782 15782 if test "x$OPENJDK_TARGET_CPU" = xx86; then
15783 15783 OPENJDK_TARGET_CPU_LEGACY="i586"
15784 15784 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15785 15785 # On all platforms except MacOSX replace x86_64 with amd64.
15786 15786 OPENJDK_TARGET_CPU_LEGACY="amd64"
15787 15787 fi
15788 15788
15789 15789
15790 15790 # And the second legacy naming of the cpu.
15791 15791 # Ie i386 and amd64 instead of x86 and x86_64.
15792 15792 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
15793 15793 if test "x$OPENJDK_TARGET_CPU" = xx86; then
15794 15794 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
15795 15795 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15796 15796 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
15797 15797 fi
15798 15798
15799 15799
15800 15800 # This is the name of the cpu (but using i386 and amd64 instead of
15801 15801 # x86 and x86_64, respectively), preceeded by a /, to be used when
15802 15802 # locating libraries. On macosx, it's empty, though.
15803 15803 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
15804 15804 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15805 15805 OPENJDK_TARGET_CPU_LIBDIR=""
15806 15806 fi
15807 15807
15808 15808
15809 15809 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15810 15810 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15811 15811 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15812 15812 OPENJDK_TARGET_CPU_ISADIR=""
15813 15813 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15814 15814 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15815 15815 OPENJDK_TARGET_CPU_ISADIR="/amd64"
15816 15816 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15817 15817 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15818 15818 fi
15819 15819 fi
15820 15820
15821 15821
15822 15822 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15823 15823 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15824 15824 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15825 15825 # On linux only, we replace x86 with i386.
15826 15826 OPENJDK_TARGET_CPU_OSARCH="i386"
15827 15827 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15828 15828 # On all platforms except macosx, we replace x86_64 with amd64.
15829 15829 OPENJDK_TARGET_CPU_OSARCH="amd64"
15830 15830 fi
15831 15831
15832 15832
15833 15833 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15834 15834 if test "x$OPENJDK_TARGET_CPU" = xx86; then
15835 15835 OPENJDK_TARGET_CPU_JLI="i386"
15836 15836 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15837 15837 # On all platforms except macosx, we replace x86_64 with amd64.
15838 15838 OPENJDK_TARGET_CPU_JLI="amd64"
15839 15839 fi
15840 15840 # Now setup the -D flags for building libjli.
15841 15841 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15842 15842 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15843 15843 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15844 15844 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15845 15845 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15846 15846 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15847 15847 fi
15848 15848 fi
15849 15849
15850 15850
15851 15851 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15852 15852 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15853 15853 else
15854 15854 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15855 15855 fi
15856 15856
15857 15857
15858 15858 # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
15859 15859 # Macosx is osx and x86_64 is x64
15860 15860 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15861 15861 OPENJDK_TARGET_OS_BUNDLE="osx"
15862 15862 else
15863 15863 OPENJDK_TARGET_OS_BUNDLE="$OPENJDK_TARGET_OS"
15864 15864 fi
15865 15865 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15866 15866 OPENJDK_TARGET_CPU_BUNDLE="x64"
15867 15867 else
15868 15868 OPENJDK_TARGET_CPU_BUNDLE="$OPENJDK_TARGET_CPU"
15869 15869 fi
15870 15870 OPENJDK_TARGET_BUNDLE_PLATFORM="${OPENJDK_TARGET_OS_BUNDLE}-${OPENJDK_TARGET_CPU_BUNDLE}"
15871 15871
15872 15872
15873 15873
15874 15874
15875 15875 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15876 15876 A_LP64="LP64:="
15877 15877 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15878 15878 # unpack200.exe
15879 15879 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15880 15880 OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
15881 15881 fi
15882 15882 fi
15883 15883 LP64=$A_LP64
15884 15884
15885 15885
15886 15886 if test "x$COMPILE_TYPE" = "xcross"; then
15887 15887 # FIXME: ... or should this include reduced builds..?
15888 15888 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15889 15889 else
15890 15890 DEFINE_CROSS_COMPILE_ARCH=""
15891 15891 fi
15892 15892
15893 15893
15894 15894 # Convert openjdk platform names to hotspot names
15895 15895
15896 15896 HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
15897 15897 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15898 15898 HOTSPOT_TARGET_OS=bsd
15899 15899 fi
15900 15900
15901 15901
15902 15902 HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
15903 15903 if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
15904 15904 HOTSPOT_TARGET_OS_TYPE=posix
15905 15905 fi
15906 15906
15907 15907
15908 15908 HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
15909 15909 if test "x$OPENJDK_TARGET_CPU" = xx86; then
15910 15910 HOTSPOT_TARGET_CPU=x86_32
15911 15911 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15912 15912 HOTSPOT_TARGET_CPU=sparc
15913 15913 elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15914 15914 HOTSPOT_TARGET_CPU=ppc_64
15915 15915 elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15916 15916 HOTSPOT_TARGET_CPU=ppc_64
15917 15917 fi
15918 15918
15919 15919
15920 15920 # This is identical with OPENJDK_*, but define anyway for consistency.
15921 15921 HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
15922 15922
15923 15923
15924 15924 # Setup HOTSPOT_TARGET_CPU_DEFINE
15925 15925 if test "x$OPENJDK_TARGET_CPU" = xx86; then
15926 15926 HOTSPOT_TARGET_CPU_DEFINE=IA32
15927 15927 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15928 15928 HOTSPOT_TARGET_CPU_DEFINE=AMD64
15929 15929 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15930 15930 HOTSPOT_TARGET_CPU_DEFINE=SPARC
15931 15931 elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15932 15932 HOTSPOT_TARGET_CPU_DEFINE=AARCH64
15933 15933 elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15934 15934 HOTSPOT_TARGET_CPU_DEFINE=PPC64
15935 15935 elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15936 15936 HOTSPOT_TARGET_CPU_DEFINE=PPC64
15937 15937
15938 15938 # The cpu defines below are for zero, we don't support them directly.
15939 15939 elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
15940 15940 HOTSPOT_TARGET_CPU_DEFINE=SPARC
15941 15941 elif test "x$OPENJDK_TARGET_CPU" = xppc; then
15942 15942 HOTSPOT_TARGET_CPU_DEFINE=PPC32
15943 15943 elif test "x$OPENJDK_TARGET_CPU" = xs390; then
15944 15944 HOTSPOT_TARGET_CPU_DEFINE=S390
15945 15945 elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
15946 15946 HOTSPOT_TARGET_CPU_DEFINE=S390
15947 15947 fi
15948 15948
15949 15949
15950 15950
15951 15951
15952 15952 # Also store the legacy naming of the cpu.
15953 15953 # Ie i586 and amd64 instead of x86 and x86_64
15954 15954 OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
15955 15955 if test "x$OPENJDK_BUILD_CPU" = xx86; then
15956 15956 OPENJDK_BUILD_CPU_LEGACY="i586"
15957 15957 elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15958 15958 # On all platforms except MacOSX replace x86_64 with amd64.
15959 15959 OPENJDK_BUILD_CPU_LEGACY="amd64"
15960 15960 fi
15961 15961
15962 15962
15963 15963 # And the second legacy naming of the cpu.
15964 15964 # Ie i386 and amd64 instead of x86 and x86_64.
15965 15965 OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
15966 15966 if test "x$OPENJDK_BUILD_CPU" = xx86; then
15967 15967 OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
15968 15968 elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15969 15969 OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
15970 15970 fi
15971 15971
15972 15972
15973 15973 # This is the name of the cpu (but using i386 and amd64 instead of
15974 15974 # x86 and x86_64, respectively), preceeded by a /, to be used when
15975 15975 # locating libraries. On macosx, it's empty, though.
15976 15976 OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
15977 15977 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15978 15978 OPENJDK_BUILD_CPU_LIBDIR=""
15979 15979 fi
15980 15980
15981 15981
15982 15982 # OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15983 15983 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15984 15984 # /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
15985 15985 OPENJDK_BUILD_CPU_ISADIR=""
15986 15986 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15987 15987 if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15988 15988 OPENJDK_BUILD_CPU_ISADIR="/amd64"
15989 15989 elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15990 15990 OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
15991 15991 fi
15992 15992 fi
15993 15993
15994 15994
15995 15995 # Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
15996 15996 OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
15997 15997 if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
15998 15998 # On linux only, we replace x86 with i386.
15999 15999 OPENJDK_BUILD_CPU_OSARCH="i386"
16000 16000 elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16001 16001 # On all platforms except macosx, we replace x86_64 with amd64.
16002 16002 OPENJDK_BUILD_CPU_OSARCH="amd64"
16003 16003 fi
16004 16004
16005 16005
16006 16006 OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
16007 16007 if test "x$OPENJDK_BUILD_CPU" = xx86; then
16008 16008 OPENJDK_BUILD_CPU_JLI="i386"
16009 16009 elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16010 16010 # On all platforms except macosx, we replace x86_64 with amd64.
16011 16011 OPENJDK_BUILD_CPU_JLI="amd64"
16012 16012 fi
16013 16013 # Now setup the -D flags for building libjli.
16014 16014 OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
16015 16015 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
16016 16016 if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
16017 16017 OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
16018 16018 elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
16019 16019 OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
16020 16020 fi
16021 16021 fi
16022 16022
16023 16023
16024 16024 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16025 16025 OPENJDK_BUILD_OS_EXPORT_DIR=macosx
16026 16026 else
16027 16027 OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
16028 16028 fi
16029 16029
16030 16030
16031 16031 # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
16032 16032 # Macosx is osx and x86_64 is x64
16033 16033 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16034 16034 OPENJDK_BUILD_OS_BUNDLE="osx"
16035 16035 else
16036 16036 OPENJDK_BUILD_OS_BUNDLE="$OPENJDK_TARGET_OS"
16037 16037 fi
16038 16038 if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16039 16039 OPENJDK_BUILD_CPU_BUNDLE="x64"
16040 16040 else
16041 16041 OPENJDK_BUILD_CPU_BUNDLE="$OPENJDK_BUILD_CPU"
16042 16042 fi
16043 16043 OPENJDK_BUILD_BUNDLE_PLATFORM="${OPENJDK_BUILD_OS_BUNDLE}-${OPENJDK_BUILD_CPU_BUNDLE}"
16044 16044
16045 16045
16046 16046
16047 16047
16048 16048 if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
16049 16049 A_LP64="LP64:="
16050 16050 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
16051 16051 # unpack200.exe
16052 16052 if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
16053 16053 OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
16054 16054 fi
16055 16055 fi
16056 16056 LP64=$A_LP64
16057 16057
16058 16058
16059 16059 if test "x$COMPILE_TYPE" = "xcross"; then
16060 16060 # FIXME: ... or should this include reduced builds..?
16061 16061 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
16062 16062 else
16063 16063 DEFINE_CROSS_COMPILE_ARCH=""
16064 16064 fi
16065 16065
16066 16066
16067 16067 # Convert openjdk platform names to hotspot names
16068 16068
16069 16069 HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
16070 16070 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16071 16071 HOTSPOT_BUILD_OS=bsd
16072 16072 fi
16073 16073
16074 16074
16075 16075 HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
16076 16076 if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
16077 16077 HOTSPOT_BUILD_OS_TYPE=posix
16078 16078 fi
16079 16079
16080 16080
16081 16081 HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
16082 16082 if test "x$OPENJDK_BUILD_CPU" = xx86; then
16083 16083 HOTSPOT_BUILD_CPU=x86_32
16084 16084 elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16085 16085 HOTSPOT_BUILD_CPU=sparc
16086 16086 elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16087 16087 HOTSPOT_BUILD_CPU=ppc_64
16088 16088 elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16089 16089 HOTSPOT_BUILD_CPU=ppc_64
16090 16090 fi
16091 16091
16092 16092
16093 16093 # This is identical with OPENJDK_*, but define anyway for consistency.
16094 16094 HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
16095 16095
16096 16096
16097 16097 # Setup HOTSPOT_BUILD_CPU_DEFINE
16098 16098 if test "x$OPENJDK_BUILD_CPU" = xx86; then
16099 16099 HOTSPOT_BUILD_CPU_DEFINE=IA32
16100 16100 elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16101 16101 HOTSPOT_BUILD_CPU_DEFINE=AMD64
16102 16102 elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16103 16103 HOTSPOT_BUILD_CPU_DEFINE=SPARC
16104 16104 elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
16105 16105 HOTSPOT_BUILD_CPU_DEFINE=AARCH64
16106 16106 elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16107 16107 HOTSPOT_BUILD_CPU_DEFINE=PPC64
16108 16108 elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16109 16109 HOTSPOT_BUILD_CPU_DEFINE=PPC64
16110 16110
16111 16111 # The cpu defines below are for zero, we don't support them directly.
16112 16112 elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
16113 16113 HOTSPOT_BUILD_CPU_DEFINE=SPARC
16114 16114 elif test "x$OPENJDK_BUILD_CPU" = xppc; then
16115 16115 HOTSPOT_BUILD_CPU_DEFINE=PPC32
16116 16116 elif test "x$OPENJDK_BUILD_CPU" = xs390; then
16117 16117 HOTSPOT_BUILD_CPU_DEFINE=S390
16118 16118 elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
16119 16119 HOTSPOT_BUILD_CPU_DEFINE=S390
16120 16120 fi
16121 16121
16122 16122
16123 16123
16124 16124
16125 16125 # ZERO_ARCHDEF is used to enable architecture-specific code.
16126 16126 # This is used in legacy hotspot build.
16127 16127 ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
16128 16128
16129 16129
16130 16130
16131 16131
16132 16132
16133 16133 # Continue setting up basic stuff. Most remaining code require fundamental tools.
16134 16134
16135 16135 # Save the current directory this script was started from
16136 16136 CURDIR="$PWD"
16137 16137
16138 16138 # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
16139 16139 # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
16140 16140 # was not available at that time.
16141 16141 REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
16142 16142 if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
16143 16143 ORIGINAL_PATH="$REWRITTEN_PATH"
16144 16144 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
16145 16145 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
16146 16146 fi
16147 16147
16148 16148 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
16149 16149 PATH_SEP=";"
16150 16150
16151 16151 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
16152 16152 if test $SRC_ROOT_LENGTH -gt 100; then
16153 16153 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
16154 16154 fi
16155 16155
16156 16156 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16157 16157 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
16158 16158 $as_echo_n "checking cygwin release... " >&6; }
16159 16159 CYGWIN_VERSION=`$UNAME -r`
16160 16160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
16161 16161 $as_echo "$CYGWIN_VERSION" >&6; }
16162 16162 WINDOWS_ENV_VENDOR='cygwin'
16163 16163 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
16164 16164
16165 16165 CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
16166 16166 if test "x$CYGWIN_VERSION_OLD" != x; then
16167 16167 { $as_echo "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
16168 16168 $as_echo "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
16169 16169 as_fn_error $? "Cannot continue" "$LINENO" 5
16170 16170 fi
16171 16171 if test "x$CYGPATH" = x; then
16172 16172 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
16173 16173 fi
16174 16174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
16175 16175 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
16176 16176 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16177 16177 cygwin_winpath_root=`cd / ; cmd /c cd | $GREP ".*"`
16178 16178 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
16179 16179 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
16180 16180 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
16181 16181 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
16182 16182 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
16183 16183 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
16184 16184 if test "x$test_cygdrive_prefix" = x; then
16185 16185 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
16186 16186 fi
16187 16187 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16188 16188 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
16189 16189 $as_echo_n "checking msys release... " >&6; }
16190 16190 MSYS_VERSION=`$UNAME -r`
16191 16191 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
16192 16192 $as_echo "$MSYS_VERSION" >&6; }
16193 16193
16194 16194 WINDOWS_ENV_VENDOR='msys'
16195 16195 WINDOWS_ENV_VERSION="$MSYS_VERSION"
16196 16196
16197 16197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
16198 16198 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
16199 16199 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16200 16200 MSYS_ROOT_PATH=`cd / ; cmd /c cd | $GREP ".*"`
16201 16201
16202 16202 windows_path="$MSYS_ROOT_PATH"
16203 16203 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16204 16204 unix_path=`$CYGPATH -u "$windows_path"`
16205 16205 MSYS_ROOT_PATH="$unix_path"
16206 16206 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16207 16207 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16208 16208 MSYS_ROOT_PATH="$unix_path"
16209 16209 fi
16210 16210
16211 16211 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
16212 16212 $as_echo "$MSYS_ROOT_PATH" >&6; }
16213 16213 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
16214 16214 else
16215 16215 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
16216 16216 fi
16217 16217
16218 16218 # Test if windows or unix (cygwin/msys) find is first in path.
16219 16219 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
16220 16220 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
16221 16221 FIND_BINARY_OUTPUT=`find --version 2>&1`
16222 16222 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
16223 16223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
16224 16224 $as_echo "unix style" >&6; }
16225 16225 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
16226 16226 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
16227 16227 $as_echo "Windows" >&6; }
16228 16228 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
16229 16229 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
16230 16230 { $as_echo "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
16231 16231 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
16232 16232 as_fn_error $? "Cannot continue" "$LINENO" 5
16233 16233 else
16234 16234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
16235 16235 $as_echo "unknown" >&6; }
16236 16236 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
16237 16237 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
16238 16238 fi
16239 16239
16240 16240 else
16241 16241 PATH_SEP=":"
16242 16242 fi
16243 16243
16244 16244
16245 16245 # We get the top-level directory from the supporting wrappers.
16246 16246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
16247 16247 $as_echo_n "checking for top-level directory... " >&6; }
16248 16248 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
16249 16249 $as_echo "$TOPDIR" >&6; }
16250 16250
16251 16251
16252 16252 # Save the original version of TOPDIR for string comparisons
16253 16253 ORIGINAL_TOPDIR="$TOPDIR"
16254 16254
16255 16255
16256 16256 # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
16257 16257
16258 16258 # Only process if variable expands to non-empty
16259 16259
16260 16260 if test "x$CURDIR" != x; then
16261 16261 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16262 16262
16263 16263 # Input might be given as Windows format, start by converting to
16264 16264 # unix format.
16265 16265 path="$CURDIR"
16266 16266 new_path=`$CYGPATH -u "$path"`
16267 16267
16268 16268 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16269 16269 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16270 16270 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16271 16271 # "foo.exe" is OK but "foo" is an error.
16272 16272 #
16273 16273 # This test is therefore slightly more accurate than "test -f" to check for file precense.
16274 16274 # It is also a way to make sure we got the proper file name for the real test later on.
16275 16275 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16276 16276 if test "x$test_shortpath" = x; then
16277 16277 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16278 16278 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16279 16279 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
16280 16280 fi
16281 16281
16282 16282 # Call helper function which possibly converts this using DOS-style short mode.
16283 16283 # If so, the updated path is stored in $new_path.
16284 16284
16285 16285 input_path="$new_path"
16286 16286 # Check if we need to convert this using DOS-style short mode. If the path
16287 16287 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16288 16288 # take no chances and rewrite it.
16289 16289 # Note: m4 eats our [], so we need to use [ and ] instead.
16290 16290 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16291 16291 if test "x$has_forbidden_chars" != x; then
16292 16292 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16293 16293 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16294 16294 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16295 16295 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16296 16296 # Going to short mode and back again did indeed matter. Since short mode is
16297 16297 # case insensitive, let's make it lowercase to improve readability.
16298 16298 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16299 16299 # Now convert it back to Unix-style (cygpath)
16300 16300 input_path=`$CYGPATH -u "$shortmode_path"`
16301 16301 new_path="$input_path"
16302 16302 fi
16303 16303 fi
16304 16304
16305 16305 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16306 16306 if test "x$test_cygdrive_prefix" = x; then
16307 16307 # As a simple fix, exclude /usr/bin since it's not a real path.
16308 16308 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16309 16309 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16310 16310 # a path prefixed by /cygdrive for fixpath to work.
16311 16311 new_path="$CYGWIN_ROOT_PATH$input_path"
16312 16312 fi
16313 16313 fi
16314 16314
16315 16315
16316 16316 if test "x$path" != "x$new_path"; then
16317 16317 CURDIR="$new_path"
16318 16318 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16319 16319 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16320 16320 fi
16321 16321
16322 16322 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16323 16323
16324 16324 path="$CURDIR"
16325 16325 has_colon=`$ECHO $path | $GREP ^.:`
16326 16326 new_path="$path"
16327 16327 if test "x$has_colon" = x; then
16328 16328 # Not in mixed or Windows style, start by that.
16329 16329 new_path=`cmd //c echo $path`
16330 16330 fi
16331 16331
16332 16332
16333 16333 input_path="$new_path"
16334 16334 # Check if we need to convert this using DOS-style short mode. If the path
16335 16335 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16336 16336 # take no chances and rewrite it.
16337 16337 # Note: m4 eats our [], so we need to use [ and ] instead.
16338 16338 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16339 16339 if test "x$has_forbidden_chars" != x; then
16340 16340 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16341 16341 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16342 16342 fi
16343 16343
16344 16344
16345 16345 windows_path="$new_path"
16346 16346 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16347 16347 unix_path=`$CYGPATH -u "$windows_path"`
16348 16348 new_path="$unix_path"
16349 16349 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16350 16350 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16351 16351 new_path="$unix_path"
16352 16352 fi
16353 16353
16354 16354 if test "x$path" != "x$new_path"; then
16355 16355 CURDIR="$new_path"
16356 16356 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16357 16357 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16358 16358 fi
16359 16359
16360 16360 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16361 16361 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16362 16362
16363 16363 else
16364 16364 # We're on a unix platform. Hooray! :)
16365 16365 path="$CURDIR"
16366 16366 has_space=`$ECHO "$path" | $GREP " "`
16367 16367 if test "x$has_space" != x; then
16368 16368 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16369 16369 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16370 16370 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16371 16371 fi
16372 16372
16373 16373 # Use eval to expand a potential ~
16374 16374 eval path="$path"
16375 16375 if test ! -f "$path" && test ! -d "$path"; then
16376 16376 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16377 16377 fi
16378 16378
16379 16379 if test -d "$path"; then
16380 16380 CURDIR="`cd "$path"; $THEPWDCMD -L`"
16381 16381 else
16382 16382 dir="`$DIRNAME "$path"`"
16383 16383 base="`$BASENAME "$path"`"
16384 16384 CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16385 16385 fi
16386 16386 fi
16387 16387 fi
16388 16388
16389 16389
16390 16390 # Only process if variable expands to non-empty
16391 16391
16392 16392 if test "x$TOPDIR" != x; then
16393 16393 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16394 16394
16395 16395 # Input might be given as Windows format, start by converting to
16396 16396 # unix format.
16397 16397 path="$TOPDIR"
16398 16398 new_path=`$CYGPATH -u "$path"`
16399 16399
16400 16400 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16401 16401 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16402 16402 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16403 16403 # "foo.exe" is OK but "foo" is an error.
16404 16404 #
16405 16405 # This test is therefore slightly more accurate than "test -f" to check for file precense.
16406 16406 # It is also a way to make sure we got the proper file name for the real test later on.
16407 16407 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16408 16408 if test "x$test_shortpath" = x; then
16409 16409 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16410 16410 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16411 16411 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
16412 16412 fi
16413 16413
16414 16414 # Call helper function which possibly converts this using DOS-style short mode.
16415 16415 # If so, the updated path is stored in $new_path.
16416 16416
16417 16417 input_path="$new_path"
16418 16418 # Check if we need to convert this using DOS-style short mode. If the path
16419 16419 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16420 16420 # take no chances and rewrite it.
16421 16421 # Note: m4 eats our [], so we need to use [ and ] instead.
16422 16422 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16423 16423 if test "x$has_forbidden_chars" != x; then
16424 16424 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16425 16425 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16426 16426 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16427 16427 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16428 16428 # Going to short mode and back again did indeed matter. Since short mode is
16429 16429 # case insensitive, let's make it lowercase to improve readability.
16430 16430 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16431 16431 # Now convert it back to Unix-style (cygpath)
16432 16432 input_path=`$CYGPATH -u "$shortmode_path"`
16433 16433 new_path="$input_path"
16434 16434 fi
16435 16435 fi
16436 16436
16437 16437 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16438 16438 if test "x$test_cygdrive_prefix" = x; then
16439 16439 # As a simple fix, exclude /usr/bin since it's not a real path.
16440 16440 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16441 16441 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16442 16442 # a path prefixed by /cygdrive for fixpath to work.
16443 16443 new_path="$CYGWIN_ROOT_PATH$input_path"
16444 16444 fi
16445 16445 fi
16446 16446
16447 16447
16448 16448 if test "x$path" != "x$new_path"; then
16449 16449 TOPDIR="$new_path"
16450 16450 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16451 16451 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16452 16452 fi
16453 16453
16454 16454 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16455 16455
16456 16456 path="$TOPDIR"
16457 16457 has_colon=`$ECHO $path | $GREP ^.:`
16458 16458 new_path="$path"
16459 16459 if test "x$has_colon" = x; then
16460 16460 # Not in mixed or Windows style, start by that.
16461 16461 new_path=`cmd //c echo $path`
16462 16462 fi
16463 16463
16464 16464
16465 16465 input_path="$new_path"
16466 16466 # Check if we need to convert this using DOS-style short mode. If the path
16467 16467 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16468 16468 # take no chances and rewrite it.
16469 16469 # Note: m4 eats our [], so we need to use [ and ] instead.
16470 16470 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16471 16471 if test "x$has_forbidden_chars" != x; then
16472 16472 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16473 16473 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16474 16474 fi
16475 16475
16476 16476
16477 16477 windows_path="$new_path"
16478 16478 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16479 16479 unix_path=`$CYGPATH -u "$windows_path"`
16480 16480 new_path="$unix_path"
16481 16481 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16482 16482 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16483 16483 new_path="$unix_path"
16484 16484 fi
16485 16485
16486 16486 if test "x$path" != "x$new_path"; then
16487 16487 TOPDIR="$new_path"
16488 16488 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16489 16489 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16490 16490 fi
16491 16491
16492 16492 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16493 16493 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16494 16494
16495 16495 else
16496 16496 # We're on a unix platform. Hooray! :)
16497 16497 path="$TOPDIR"
16498 16498 has_space=`$ECHO "$path" | $GREP " "`
16499 16499 if test "x$has_space" != x; then
16500 16500 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16501 16501 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16502 16502 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16503 16503 fi
16504 16504
16505 16505 # Use eval to expand a potential ~
16506 16506 eval path="$path"
16507 16507 if test ! -f "$path" && test ! -d "$path"; then
16508 16508 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16509 16509 fi
16510 16510
16511 16511 if test -d "$path"; then
16512 16512 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
16513 16513 else
16514 16514 dir="`$DIRNAME "$path"`"
16515 16515 base="`$BASENAME "$path"`"
16516 16516 TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16517 16517 fi
16518 16518 fi
16519 16519 fi
16520 16520
16521 16521 # SRC_ROOT is a traditional alias for TOPDIR.
16522 16522 SRC_ROOT=$TOPDIR
16523 16523
16524 16524 # Calculate a canonical version of TOPDIR for string comparisons
16525 16525 CANONICAL_TOPDIR=$TOPDIR
16526 16526
16527 16527 if test "x$OPENJDK_BUILD_OS" != xwindows; then
16528 16528 # Follow a chain of symbolic links. Use readlink
16529 16529 # where it exists, else fall back to horribly
16530 16530 # complicated shell code.
16531 16531 if test "x$READLINK_TESTED" != yes; then
16532 16532 # On MacOSX there is a readlink tool with a different
16533 16533 # purpose than the GNU readlink tool. Check the found readlink.
16534 16534 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
16535 16535 if test "x$ISGNU" = x; then
16536 16536 # A readlink that we do not know how to use.
16537 16537 # Are there other non-GNU readlinks out there?
16538 16538 READLINK_TESTED=yes
16539 16539 READLINK=
16540 16540 fi
16541 16541 fi
16542 16542
16543 16543 if test "x$READLINK" != x; then
16544 16544 CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
16545 16545 else
16546 16546 # Save the current directory for restoring afterwards
16547 16547 STARTDIR=$PWD
16548 16548 COUNTER=0
16549 16549 sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
16550 16550 sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
16551 16551 cd $sym_link_dir
16552 16552 # Use -P flag to resolve symlinks in directories.
16553 16553 cd `$THEPWDCMD -P`
16554 16554 sym_link_dir=`$THEPWDCMD -P`
16555 16555 # Resolve file symlinks
16556 16556 while test $COUNTER -lt 20; do
16557 16557 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
16558 16558 if test "x$ISLINK" == x; then
16559 16559 # This is not a symbolic link! We are done!
16560 16560 break
16561 16561 fi
16562 16562 # Again resolve directory symlinks since the target of the just found
16563 16563 # link could be in a different directory
16564 16564 cd `$DIRNAME $ISLINK`
16565 16565 sym_link_dir=`$THEPWDCMD -P`
16566 16566 sym_link_file=`$BASENAME $ISLINK`
16567 16567 let COUNTER=COUNTER+1
16568 16568 done
16569 16569 cd $STARTDIR
16570 16570 CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
16571 16571 fi
16572 16572 fi
16573 16573
16574 16574
16575 16575
16576 16576 # Locate the directory of this script.
16577 16577 AUTOCONF_DIR=$TOPDIR/common/autoconf
16578 16578
16579 16579 # Setup username (for use in adhoc version strings etc)
16580 16580 # Outer [ ] to quote m4.
16581 16581 USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
16582 16582
16583 16583
16584 16584
16585 16585 # Check if it's a pure open build or if custom sources are to be used.
16586 16586
16587 16587 # Check whether --enable-openjdk-only was given.
16588 16588 if test "${enable_openjdk_only+set}" = set; then :
16589 16589 enableval=$enable_openjdk_only;
16590 16590 else
16591 16591 enable_openjdk_only="no"
16592 16592 fi
16593 16593
16594 16594
16595 16595 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if custom source is suppressed (openjdk-only)" >&5
16596 16596 $as_echo_n "checking if custom source is suppressed (openjdk-only)... " >&6; }
16597 16597 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_openjdk_only" >&5
16598 16598 $as_echo "$enable_openjdk_only" >&6; }
16599 16599 if test "x$enable_openjdk_only" = "xyes"; then
16600 16600 SUPPRESS_CUSTOM_EXTENSIONS="true"
16601 16601 elif test "x$enable_openjdk_only" = "xno"; then
16602 16602 SUPPRESS_CUSTOM_EXTENSIONS="false"
16603 16603 else
16604 16604 as_fn_error $? "Invalid value for --enable-openjdk-only: $enable_openjdk_only" "$LINENO" 5
16605 16605 fi
16606 16606
16607 16607 # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
16608 16608 # the IncludeCustomExtension macro.
16609 16609
16610 16610
16611 16611 # Check whether --with-custom-make-dir was given.
16612 16612 if test "${with_custom_make_dir+set}" = set; then :
16613 16613 withval=$with_custom_make_dir; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&5
16614 16614 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
16615 16615 fi
16616 16616
16617 16617
16618 16618
16619 16619
16620 16620 # These are needed to be able to create a configuration name (and thus the output directory)
16621 16621
16622 16622 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
16623 16623 $as_echo_n "checking which variant of the JDK to build... " >&6; }
16624 16624
16625 16625 # Check whether --with-jdk-variant was given.
16626 16626 if test "${with_jdk_variant+set}" = set; then :
16627 16627 withval=$with_jdk_variant;
16628 16628 fi
16629 16629
16630 16630
16631 16631 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
16632 16632 JDK_VARIANT="normal"
16633 16633 else
16634 16634 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
16635 16635 fi
16636 16636
16637 16637
16638 16638
16639 16639 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
16640 16640 $as_echo "$JDK_VARIANT" >&6; }
16641 16641
16642 16642
16643 16643 DEBUG_LEVEL="release"
16644 16644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
16645 16645 $as_echo_n "checking which debug level to use... " >&6; }
16646 16646 # Check whether --enable-debug was given.
16647 16647 if test "${enable_debug+set}" = set; then :
16648 16648 enableval=$enable_debug;
16649 16649 ENABLE_DEBUG="${enableval}"
16650 16650 DEBUG_LEVEL="fastdebug"
16651 16651
16652 16652 else
16653 16653 ENABLE_DEBUG="no"
16654 16654 fi
16655 16655
16656 16656
16657 16657
16658 16658 # Check whether --with-debug-level was given.
16659 16659 if test "${with_debug_level+set}" = set; then :
16660 16660 withval=$with_debug_level;
16661 16661 DEBUG_LEVEL="${withval}"
16662 16662 if test "x$ENABLE_DEBUG" = xyes; then
16663 16663 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
16664 16664 fi
16665 16665
16666 16666 fi
16667 16667
16668 16668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
16669 16669 $as_echo "$DEBUG_LEVEL" >&6; }
16670 16670
16671 16671 if test "x$DEBUG_LEVEL" != xrelease && \
16672 16672 test "x$DEBUG_LEVEL" != xoptimized && \
16673 16673 test "x$DEBUG_LEVEL" != xfastdebug && \
16674 16674 test "x$DEBUG_LEVEL" != xslowdebug; then
16675 16675 as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
16676 16676 fi
16677 16677
16678 16678 # Translate DEBUG_LEVEL to debug level used by Hotspot
16679 16679 HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
16680 16680 if test "x$DEBUG_LEVEL" = xrelease; then
16681 16681 HOTSPOT_DEBUG_LEVEL="product"
16682 16682 elif test "x$DEBUG_LEVEL" = xslowdebug; then
16683 16683 HOTSPOT_DEBUG_LEVEL="debug"
16684 16684 fi
16685 16685
16686 16686 if test "x$DEBUG_LEVEL" = xoptimized; then
16687 16687 # The debug level 'optimized' is a little special because it is currently only
16688 16688 # applicable to the HotSpot build where it means to build a completely
16689 16689 # optimized version of the VM without any debugging code (like for the
16690 16690 # 'release' debug level which is called 'product' in the HotSpot build) but
16691 16691 # with the exception that it can contain additional code which is otherwise
16692 16692 # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
16693 16693 # test new and/or experimental features which are not intended for customer
16694 16694 # shipment. Because these new features need to be tested and benchmarked in
16695 16695 # real world scenarios, we want to build the containing JDK at the 'release'
16696 16696 # debug level.
16697 16697 DEBUG_LEVEL="release"
16698 16698 fi
16699 16699
16700 16700
16701 16701
16702 16702
16703 16703
16704 16704
16705 16705 # Check whether --with-jvm-variants was given.
16706 16706 if test "${with_jvm_variants+set}" = set; then :
16707 16707 withval=$with_jvm_variants;
16708 16708 fi
16709 16709
16710 16710
16711 16711 if test "x$with_jvm_variants" = x; then
16712 16712 with_jvm_variants="server"
16713 16713 fi
16714 16714 JVM_VARIANTS_OPT="$with_jvm_variants"
16715 16715
16716 16716 # Has the user listed more than one variant?
16717 16717 # Additional [] needed to keep m4 from mangling shell constructs.
16718 16718 if [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
16719 16719 BUILDING_MULTIPLE_JVM_VARIANTS=true
16720 16720 else
16721 16721 BUILDING_MULTIPLE_JVM_VARIANTS=false
16722 16722 fi
16723 16723 # Replace the commas with AND for use in the build directory name.
16724 16724 JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
16725 16725
16726 16726 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
16727 16727 $as_echo_n "checking which variants of the JVM to build... " >&6; }
16728 16728 # JVM_VARIANTS is a space-separated list.
16729 16729 # Also use minimal, not minimal1 (which is kept for backwards compatibility).
16730 16730 JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
16731 16731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
16732 16732 $as_echo "$JVM_VARIANTS" >&6; }
16733 16733
16734 16734 # Check that the selected variants are valid
16735 16735
16736 16736 # grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
16737 16737 # Notice that the original variant failes on SLES 10 and 11
16738 16738 NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
16739 16739 STACK=${JVM_VARIANTS// /$'\n'}
16740 16740 INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16741 16741 if test "x$INVALID_VARIANTS" != x; then
16742 16742 { $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
16743 16743 $as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
16744 16744 as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
16745 16745 fi
16746 16746
16747 16747 # All "special" variants share the same output directory ("server")
16748 16748 VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
16749 16749 NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
16750 16750 STACK=${JVM_VARIANTS// /$'\n'}
16751 16751 INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16752 16752 if test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
16753 16753 as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
16754 16754 fi
16755 16755
16756 16756
16757 16757
16758 16758
16759 16759 if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
16760 16760 # zero behaves as a platform and rewrites these values. This is really weird. :(
16761 16761 # We are guaranteed that we do not build any other variants when building zero.
16762 16762 HOTSPOT_TARGET_CPU=zero
16763 16763 HOTSPOT_TARGET_CPU_ARCH=zero
16764 16764 fi
16765 16765
16766 16766
16767 16767 # With basic setup done, call the custom early hook.
16768 16768
16769 16769
16770 16770 # Check if we have devkits, extra paths or sysroot set.
16771 16771
16772 16772
16773 16773 # Check whether --with-devkit was given.
16774 16774 if test "${with_devkit+set}" = set; then :
16775 16775 withval=$with_devkit;
16776 16776
16777 16777 # Only process if variable expands to non-empty
16778 16778
16779 16779 if test "x$with_devkit" != x; then
16780 16780 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16781 16781
16782 16782 # Input might be given as Windows format, start by converting to
16783 16783 # unix format.
16784 16784 path="$with_devkit"
16785 16785 new_path=`$CYGPATH -u "$path"`
16786 16786
16787 16787 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16788 16788 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16789 16789 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16790 16790 # "foo.exe" is OK but "foo" is an error.
16791 16791 #
16792 16792 # This test is therefore slightly more accurate than "test -f" to check for file precense.
16793 16793 # It is also a way to make sure we got the proper file name for the real test later on.
16794 16794 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16795 16795 if test "x$test_shortpath" = x; then
16796 16796 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16797 16797 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16798 16798 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
16799 16799 fi
16800 16800
16801 16801 # Call helper function which possibly converts this using DOS-style short mode.
16802 16802 # If so, the updated path is stored in $new_path.
16803 16803
16804 16804 input_path="$new_path"
16805 16805 # Check if we need to convert this using DOS-style short mode. If the path
16806 16806 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16807 16807 # take no chances and rewrite it.
16808 16808 # Note: m4 eats our [], so we need to use [ and ] instead.
16809 16809 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16810 16810 if test "x$has_forbidden_chars" != x; then
16811 16811 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16812 16812 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16813 16813 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16814 16814 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16815 16815 # Going to short mode and back again did indeed matter. Since short mode is
16816 16816 # case insensitive, let's make it lowercase to improve readability.
16817 16817 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16818 16818 # Now convert it back to Unix-style (cygpath)
16819 16819 input_path=`$CYGPATH -u "$shortmode_path"`
16820 16820 new_path="$input_path"
16821 16821 fi
16822 16822 fi
16823 16823
16824 16824 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16825 16825 if test "x$test_cygdrive_prefix" = x; then
16826 16826 # As a simple fix, exclude /usr/bin since it's not a real path.
16827 16827 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16828 16828 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16829 16829 # a path prefixed by /cygdrive for fixpath to work.
16830 16830 new_path="$CYGWIN_ROOT_PATH$input_path"
16831 16831 fi
16832 16832 fi
16833 16833
16834 16834
16835 16835 if test "x$path" != "x$new_path"; then
16836 16836 with_devkit="$new_path"
16837 16837 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16838 16838 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16839 16839 fi
16840 16840
16841 16841 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16842 16842
16843 16843 path="$with_devkit"
16844 16844 has_colon=`$ECHO $path | $GREP ^.:`
16845 16845 new_path="$path"
16846 16846 if test "x$has_colon" = x; then
16847 16847 # Not in mixed or Windows style, start by that.
16848 16848 new_path=`cmd //c echo $path`
16849 16849 fi
16850 16850
16851 16851
16852 16852 input_path="$new_path"
16853 16853 # Check if we need to convert this using DOS-style short mode. If the path
16854 16854 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16855 16855 # take no chances and rewrite it.
16856 16856 # Note: m4 eats our [], so we need to use [ and ] instead.
16857 16857 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16858 16858 if test "x$has_forbidden_chars" != x; then
16859 16859 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16860 16860 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16861 16861 fi
16862 16862
16863 16863
16864 16864 windows_path="$new_path"
16865 16865 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16866 16866 unix_path=`$CYGPATH -u "$windows_path"`
16867 16867 new_path="$unix_path"
16868 16868 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16869 16869 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16870 16870 new_path="$unix_path"
16871 16871 fi
16872 16872
16873 16873 if test "x$path" != "x$new_path"; then
16874 16874 with_devkit="$new_path"
16875 16875 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16876 16876 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16877 16877 fi
16878 16878
16879 16879 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16880 16880 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16881 16881
16882 16882 else
16883 16883 # We're on a unix platform. Hooray! :)
16884 16884 path="$with_devkit"
16885 16885 has_space=`$ECHO "$path" | $GREP " "`
16886 16886 if test "x$has_space" != x; then
16887 16887 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16888 16888 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16889 16889 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16890 16890 fi
16891 16891
16892 16892 # Use eval to expand a potential ~
16893 16893 eval path="$path"
16894 16894 if test ! -f "$path" && test ! -d "$path"; then
16895 16895 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16896 16896 fi
16897 16897
16898 16898 if test -d "$path"; then
16899 16899 with_devkit="`cd "$path"; $THEPWDCMD -L`"
16900 16900 else
16901 16901 dir="`$DIRNAME "$path"`"
16902 16902 base="`$BASENAME "$path"`"
16903 16903 with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
16904 16904 fi
16905 16905 fi
16906 16906 fi
16907 16907
16908 16908 DEVKIT_ROOT="$with_devkit"
16909 16909 # Check for a meta data info file in the root of the devkit
16910 16910 if test -f "$DEVKIT_ROOT/devkit.info"; then
16911 16911 . $DEVKIT_ROOT/devkit.info
16912 16912 # This potentially sets the following:
16913 16913 # A descriptive name of the devkit
16914 16914
16915 16915 if test "x$DEVKIT_NAME" = x; then
16916 16916 eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16917 16917 fi
16918 16918
16919 16919 # Corresponds to --with-extra-path
16920 16920
16921 16921 if test "x$DEVKIT_EXTRA_PATH" = x; then
16922 16922 eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16923 16923 fi
16924 16924
16925 16925 # Corresponds to --with-toolchain-path
16926 16926
16927 16927 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16928 16928 eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16929 16929 fi
16930 16930
16931 16931 # Corresponds to --with-sysroot
16932 16932
16933 16933 if test "x$DEVKIT_SYSROOT" = x; then
16934 16934 eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16935 16935 fi
16936 16936
16937 16937
16938 16938 # Identifies the Visual Studio version in the devkit
16939 16939
16940 16940 if test "x$DEVKIT_VS_VERSION" = x; then
16941 16941 eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16942 16942 fi
16943 16943
16944 16944 # The Visual Studio include environment variable
16945 16945
16946 16946 if test "x$DEVKIT_VS_INCLUDE" = x; then
16947 16947 eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16948 16948 fi
16949 16949
16950 16950 # The Visual Studio lib environment variable
16951 16951
16952 16952 if test "x$DEVKIT_VS_LIB" = x; then
16953 16953 eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16954 16954 fi
16955 16955
16956 16956 # Corresponds to --with-msvcr-dll
16957 16957
16958 16958 if test "x$DEVKIT_MSVCR_DLL" = x; then
16959 16959 eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16960 16960 fi
16961 16961
16962 16962 # Corresponds to --with-msvcp-dll
16963 16963
16964 16964 if test "x$DEVKIT_MSVCP_DLL" = x; then
16965 16965 eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16966 16966 fi
16967 16967
16968 16968 fi
16969 16969
16970 16970 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16971 16971 $as_echo_n "checking for devkit... " >&6; }
16972 16972 if test "x$DEVKIT_NAME" != x; then
16973 16973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16974 16974 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16975 16975 else
16976 16976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16977 16977 $as_echo "$DEVKIT_ROOT" >&6; }
16978 16978 fi
16979 16979
16980 16980
16981 16981 if test "x$DEVKIT_EXTRA_PATH" != x; then
16982 16982 if test "x$EXTRA_PATH" = x; then
16983 16983 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16984 16984 else
16985 16985 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16986 16986 fi
16987 16987 fi
16988 16988
16989 16989
16990 16990 # Fallback default of just /bin if DEVKIT_PATH is not defined
16991 16991 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16992 16992 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16993 16993 fi
16994 16994
16995 16995 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16996 16996 if test "x$TOOLCHAIN_PATH" = x; then
16997 16997 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16998 16998 else
16999 16999 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
17000 17000 fi
17001 17001 fi
17002 17002
17003 17003
17004 17004 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
17005 17005 # places for backwards compatiblity.
17006 17006 if test "x$DEVKIT_SYSROOT" != x; then
17007 17007 SYSROOT="$DEVKIT_SYSROOT"
17008 17008 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
17009 17009 SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
17010 17010 elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
17011 17011 SYSROOT="$DEVKIT_ROOT/$host/sys-root"
17012 17012 fi
17013 17013
17014 17014
17015 17015 fi
17016 17016
17017 17017
17018 17018 # You can force the sysroot if the sysroot encoded into the compiler tools
17019 17019 # is not correct.
17020 17020
17021 17021 # Check whether --with-sys-root was given.
17022 17022 if test "${with_sys_root+set}" = set; then :
17023 17023 withval=$with_sys_root; SYSROOT=$with_sys_root
17024 17024
17025 17025 fi
17026 17026
17027 17027
17028 17028
17029 17029 # Check whether --with-sysroot was given.
17030 17030 if test "${with_sysroot+set}" = set; then :
17031 17031 withval=$with_sysroot; SYSROOT=$with_sysroot
17032 17032
17033 17033 fi
17034 17034
17035 17035
17036 17036
17037 17037 # Check whether --with-tools-dir was given.
17038 17038 if test "${with_tools_dir+set}" = set; then :
17039 17039 withval=$with_tools_dir;
17040 17040 if test "x$with_tools_dir" != x; then
17041 17041 if test "x$TOOLCHAIN_PATH" = x; then
17042 17042 TOOLCHAIN_PATH="$with_tools_dir"
17043 17043 else
17044 17044 TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
17045 17045 fi
17046 17046 fi
17047 17047
17048 17048
17049 17049 fi
17050 17050
17051 17051
17052 17052
17053 17053 # Check whether --with-toolchain-path was given.
17054 17054 if test "${with_toolchain_path+set}" = set; then :
17055 17055 withval=$with_toolchain_path;
17056 17056 if test "x$with_toolchain_path" != x; then
17057 17057 if test "x$TOOLCHAIN_PATH" = x; then
17058 17058 TOOLCHAIN_PATH="$with_toolchain_path"
17059 17059 else
17060 17060 TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
17061 17061 fi
17062 17062 fi
17063 17063
17064 17064
17065 17065 fi
17066 17066
17067 17067
17068 17068
17069 17069 # Check whether --with-extra-path was given.
17070 17070 if test "${with_extra_path+set}" = set; then :
17071 17071 withval=$with_extra_path;
17072 17072 if test "x$with_extra_path" != x; then
17073 17073 if test "x$EXTRA_PATH" = x; then
17074 17074 EXTRA_PATH="$with_extra_path"
17075 17075 else
17076 17076 EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
17077 17077 fi
17078 17078 fi
17079 17079
17080 17080
17081 17081 fi
17082 17082
17083 17083
17084 17084 if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
17085 17085 # If a devkit has been supplied, find xcodebuild in the toolchain_path.
17086 17086 # If not, detect if Xcode is installed by running xcodebuild -version
17087 17087 # if no Xcode installed, xcodebuild exits with 1
17088 17088 # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
17089 17089 if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
17090 17090 # We need to use xcodebuild in the toolchain dir provided by the user, this will
17091 17091 # fall back on the stub binary in /usr/bin/xcodebuild
17092 17092 # Extract the first word of "xcodebuild", so it can be a program name with args.
17093 17093 set dummy xcodebuild; ac_word=$2
17094 17094 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17095 17095 $as_echo_n "checking for $ac_word... " >&6; }
17096 17096 if ${ac_cv_path_XCODEBUILD+:} false; then :
17097 17097 $as_echo_n "(cached) " >&6
17098 17098 else
17099 17099 case $XCODEBUILD in
17100 17100 [\\/]* | ?:[\\/]*)
17101 17101 ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
17102 17102 ;;
17103 17103 *)
17104 17104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17105 17105 for as_dir in $TOOLCHAIN_PATH
17106 17106 do
17107 17107 IFS=$as_save_IFS
17108 17108 test -z "$as_dir" && as_dir=.
17109 17109 for ac_exec_ext in '' $ac_executable_extensions; do
17110 17110 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17111 17111 ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
17112 17112 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17113 17113 break 2
17114 17114 fi
17115 17115 done
17116 17116 done
17117 17117 IFS=$as_save_IFS
17118 17118
17119 17119 test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
17120 17120 ;;
17121 17121 esac
17122 17122 fi
17123 17123 XCODEBUILD=$ac_cv_path_XCODEBUILD
17124 17124 if test -n "$XCODEBUILD"; then
17125 17125 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
17126 17126 $as_echo "$XCODEBUILD" >&6; }
17127 17127 else
17128 17128 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17129 17129 $as_echo "no" >&6; }
17130 17130 fi
17131 17131
17132 17132
17133 17133 else
17134 17134 # this should result in SYSROOT being empty, unless --with-sysroot is provided
17135 17135 # when only the command line tools are installed there are no SDKs, so headers
17136 17136 # are copied into the system frameworks
17137 17137 XCODEBUILD=
17138 17138
17139 17139 fi
17140 17140
17141 17141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
17142 17142 $as_echo_n "checking for sdk name... " >&6; }
17143 17143
17144 17144 # Check whether --with-sdk-name was given.
17145 17145 if test "${with_sdk_name+set}" = set; then :
17146 17146 withval=$with_sdk_name; SDKNAME=$with_sdk_name
17147 17147
17148 17148 fi
17149 17149
17150 17150 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
17151 17151 $as_echo "$SDKNAME" >&6; }
17152 17152
17153 17153 # if toolchain path is specified then don't rely on system headers, they may not compile
17154 17154 HAVE_SYSTEM_FRAMEWORK_HEADERS=0
17155 17155 test -z "$TOOLCHAIN_PATH" && \
17156 17156 HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
17157 17157
17158 17158 if test -z "$SYSROOT"; then
17159 17159 if test -n "$XCODEBUILD"; then
17160 17160 # if we don't have system headers, use default SDK name (last resort)
17161 17161 if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17162 17162 SDKNAME=${SDKNAME:-macosx}
17163 17163 fi
17164 17164
17165 17165 if test -n "$SDKNAME"; then
17166 17166 # Call xcodebuild to determine SYSROOT
17167 17167 SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | $GREP '^Path: ' | $SED 's/Path: //'`
17168 17168 fi
17169 17169 else
17170 17170 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17171 17171 as_fn_error $? "No xcodebuild tool and no system framework headers found, use --with-sysroot or --with-sdk-name to provide a path to a valid SDK" "$LINENO" 5
17172 17172 fi
17173 17173 fi
17174 17174 else
17175 17175 # warn user if --with-sdk-name was also set
17176 17176 if test -n "$with_sdk_name"; then
17177 17177 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
17178 17178 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
17179 17179 fi
17180 17180 fi
17181 17181
17182 17182 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
17183 17183 # If no system framework headers, then SYSROOT must be set, or we won't build
17184 17184 as_fn_error $? "Unable to determine SYSROOT and no headers found in /System/Library/Frameworks. Check Xcode configuration, --with-sysroot or --with-sdk-name arguments." "$LINENO" 5
17185 17185 fi
17186 17186
17187 17187 # Perform a basic sanity test
17188 17188 if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
17189 17189 if test -z "$SYSROOT"; then
17190 17190 as_fn_error $? "Unable to find required framework headers, provide a path to an SDK via --with-sysroot or --with-sdk-name and be sure Xcode is installed properly" "$LINENO" 5
17191 17191 else
17192 17192 as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
17193 17193 fi
17194 17194 fi
17195 17195
17196 17196 # set SDKROOT too, Xcode tools will pick it up
17197 17197 SDKROOT=$SYSROOT
17198 17198
17199 17199 fi
17200 17200
17201 17201 # Prepend the extra path to the global path
17202 17202
17203 17203 if test "x$EXTRA_PATH" != x; then
17204 17204 if test "x$PATH" = x; then
17205 17205 PATH="$EXTRA_PATH"
17206 17206 else
17207 17207 PATH="$EXTRA_PATH:$PATH"
17208 17208 fi
17209 17209 fi
17210 17210
17211 17211
17212 17212 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
17213 17213 # Add extra search paths on solaris for utilities like ar, as, dtrace etc...
17214 17214 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
17215 17215 fi
17216 17216
17217 17217 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
17218 17218 $as_echo_n "checking for sysroot... " >&6; }
17219 17219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
17220 17220 $as_echo "$SYSROOT" >&6; }
17221 17221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
17222 17222 $as_echo_n "checking for toolchain path... " >&6; }
17223 17223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
17224 17224 $as_echo "$TOOLCHAIN_PATH" >&6; }
17225 17225 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
17226 17226 $as_echo_n "checking for extra path... " >&6; }
17227 17227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
17228 17228 $as_echo "$EXTRA_PATH" >&6; }
17229 17229
17230 17230
17231 17231 # To properly create a configuration name, we need to have the OpenJDK target
17232 17232 # and options (variants and debug level) parsed.
17233 17233
17234 17234
17235 17235
17236 17236 # Check whether --with-conf-name was given.
17237 17237 if test "${with_conf_name+set}" = set; then :
17238 17238 withval=$with_conf_name; CONF_NAME=${with_conf_name}
17239 17239 fi
17240 17240
17241 17241
17242 17242 # Test from where we are running configure, in or outside of src root.
17243 17243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
17244 17244 $as_echo_n "checking where to store configuration... " >&6; }
17245 17245 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
17246 17246 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
17247 17247 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
17248 17248 # We are running configure from the src root.
17249 17249 # Create a default ./build/target-variant-debuglevel output root.
17250 17250 if test "x${CONF_NAME}" = x; then
17251 17251 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
17252 17252 $as_echo "in default location" >&6; }
17253 17253 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
17254 17254 else
17255 17255 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
17256 17256 $as_echo "in build directory with custom name" >&6; }
17257 17257 fi
17258 17258 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
17259 17259 $MKDIR -p "$OUTPUT_ROOT"
17260 17260 if test ! -d "$OUTPUT_ROOT"; then
17261 17261 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
17262 17262 fi
17263 17263 else
17264 17264 # We are running configure from outside of the src dir.
17265 17265 # Then use the current directory as output dir!
17266 17266 # If configuration is situated in normal build directory, just use the build
17267 17267 # directory name as configuration name, otherwise use the complete path.
17268 17268 if test "x${CONF_NAME}" = x; then
17269 17269 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
17270 17270 fi
17271 17271 OUTPUT_ROOT="$CURDIR"
17272 17272 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
17273 17273 $as_echo "in current directory" >&6; }
17274 17274
17275 17275 # WARNING: This might be a bad thing to do. You need to be sure you want to
17276 17276 # have a configuration in this directory. Do some sanity checks!
17277 17277
17278 17278 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
17279 17279 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
17280 17280 # other files
17281 17281 files_present=`$LS $OUTPUT_ROOT`
17282 17282 # Configure has already touched config.log and confdefs.h in the current dir when this check
17283 17283 # is performed.
17284 17284 filtered_files=`$ECHO "$files_present" \
17285 17285 | $SED -e 's/config.log//g' \
17286 17286 -e 's/configure.log//g' \
17287 17287 -e 's/confdefs.h//g' \
17288 17288 -e 's/ //g' \
17289 17289 | $TR -d '\n'`
17290 17290 if test "x$filtered_files" != x; then
17291 17291 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
17292 17292 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
17293 17293 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
17294 17294 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
17295 17295 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
17296 17296 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
17297 17297 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
17298 17298 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
17299 17299 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
17300 17300 $as_echo "$as_me: seriously mess up just about everything." >&6;}
17301 17301 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
17302 17302 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
17303 17303 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
17304 17304 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
17305 17305 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
17306 17306 fi
17307 17307 fi
17308 17308 fi
17309 17309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
17310 17310 $as_echo_n "checking what configuration name to use... " >&6; }
17311 17311 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
17312 17312 $as_echo "$CONF_NAME" >&6; }
17313 17313
17314 17314
17315 17315 # Only process if variable expands to non-empty
17316 17316
17317 17317 if test "x$OUTPUT_ROOT" != x; then
17318 17318 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17319 17319
17320 17320 # Input might be given as Windows format, start by converting to
17321 17321 # unix format.
17322 17322 path="$OUTPUT_ROOT"
17323 17323 new_path=`$CYGPATH -u "$path"`
17324 17324
17325 17325 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17326 17326 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17327 17327 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17328 17328 # "foo.exe" is OK but "foo" is an error.
17329 17329 #
17330 17330 # This test is therefore slightly more accurate than "test -f" to check for file precense.
17331 17331 # It is also a way to make sure we got the proper file name for the real test later on.
17332 17332 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17333 17333 if test "x$test_shortpath" = x; then
17334 17334 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17335 17335 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17336 17336 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
17337 17337 fi
17338 17338
17339 17339 # Call helper function which possibly converts this using DOS-style short mode.
17340 17340 # If so, the updated path is stored in $new_path.
17341 17341
17342 17342 input_path="$new_path"
17343 17343 # Check if we need to convert this using DOS-style short mode. If the path
17344 17344 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17345 17345 # take no chances and rewrite it.
17346 17346 # Note: m4 eats our [], so we need to use [ and ] instead.
17347 17347 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17348 17348 if test "x$has_forbidden_chars" != x; then
17349 17349 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17350 17350 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17351 17351 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17352 17352 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17353 17353 # Going to short mode and back again did indeed matter. Since short mode is
17354 17354 # case insensitive, let's make it lowercase to improve readability.
17355 17355 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17356 17356 # Now convert it back to Unix-style (cygpath)
17357 17357 input_path=`$CYGPATH -u "$shortmode_path"`
17358 17358 new_path="$input_path"
17359 17359 fi
17360 17360 fi
17361 17361
17362 17362 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17363 17363 if test "x$test_cygdrive_prefix" = x; then
17364 17364 # As a simple fix, exclude /usr/bin since it's not a real path.
17365 17365 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
17366 17366 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17367 17367 # a path prefixed by /cygdrive for fixpath to work.
17368 17368 new_path="$CYGWIN_ROOT_PATH$input_path"
17369 17369 fi
17370 17370 fi
17371 17371
17372 17372
17373 17373 if test "x$path" != "x$new_path"; then
17374 17374 OUTPUT_ROOT="$new_path"
17375 17375 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17376 17376 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17377 17377 fi
17378 17378
17379 17379 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17380 17380
17381 17381 path="$OUTPUT_ROOT"
17382 17382 has_colon=`$ECHO $path | $GREP ^.:`
17383 17383 new_path="$path"
17384 17384 if test "x$has_colon" = x; then
17385 17385 # Not in mixed or Windows style, start by that.
17386 17386 new_path=`cmd //c echo $path`
17387 17387 fi
17388 17388
17389 17389
17390 17390 input_path="$new_path"
17391 17391 # Check if we need to convert this using DOS-style short mode. If the path
17392 17392 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17393 17393 # take no chances and rewrite it.
17394 17394 # Note: m4 eats our [], so we need to use [ and ] instead.
17395 17395 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17396 17396 if test "x$has_forbidden_chars" != x; then
17397 17397 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17398 17398 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17399 17399 fi
17400 17400
17401 17401
17402 17402 windows_path="$new_path"
17403 17403 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17404 17404 unix_path=`$CYGPATH -u "$windows_path"`
17405 17405 new_path="$unix_path"
17406 17406 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17407 17407 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17408 17408 new_path="$unix_path"
17409 17409 fi
17410 17410
17411 17411 if test "x$path" != "x$new_path"; then
17412 17412 OUTPUT_ROOT="$new_path"
17413 17413 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17414 17414 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17415 17415 fi
17416 17416
17417 17417 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17418 17418 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17419 17419
17420 17420 else
17421 17421 # We're on a unix platform. Hooray! :)
17422 17422 path="$OUTPUT_ROOT"
17423 17423 has_space=`$ECHO "$path" | $GREP " "`
17424 17424 if test "x$has_space" != x; then
17425 17425 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17426 17426 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17427 17427 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
17428 17428 fi
17429 17429
17430 17430 # Use eval to expand a potential ~
17431 17431 eval path="$path"
17432 17432 if test ! -f "$path" && test ! -d "$path"; then
17433 17433 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
17434 17434 fi
17435 17435
17436 17436 if test -d "$path"; then
17437 17437 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
17438 17438 else
17439 17439 dir="`$DIRNAME "$path"`"
17440 17440 base="`$BASENAME "$path"`"
17441 17441 OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
17442 17442 fi
17443 17443 fi
17444 17444 fi
17445 17445
17446 17446
17447 17447 CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
17448 17448 $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
17449 17449
17450 17450 SPEC=$OUTPUT_ROOT/spec.gmk
17451 17451
17452 17452 CONF_NAME=$CONF_NAME
17453 17453
17454 17454 OUTPUT_ROOT=$OUTPUT_ROOT
17455 17455
17456 17456
17457 17457
17458 17458 # The spec.gmk file contains all variables for the make system.
17459 17459 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
17460 17460
17461 17461 # The bootcycle-spec.gmk file contains support for boot cycle builds.
17462 17462 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
17463 17463
17464 17464 # The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
17465 17465 ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
17466 17466
17467 17467 # The compare.sh is used to compare the build output to other builds.
17468 17468 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
17469 17469
17470 17470 # The generated Makefile knows where the spec.gmk is and where the source is.
17471 17471 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
17472 17472 # which will look for generated configurations
17473 17473 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
17474 17474
17475 17475
17476 17476
17477 17477 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
17478 17478
17479 17479 for ac_prog in apt-get yum port pkgutil pkgadd
17480 17480 do
17481 17481 # Extract the first word of "$ac_prog", so it can be a program name with args.
17482 17482 set dummy $ac_prog; ac_word=$2
17483 17483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17484 17484 $as_echo_n "checking for $ac_word... " >&6; }
17485 17485 if ${ac_cv_prog_PKGHANDLER+:} false; then :
17486 17486 $as_echo_n "(cached) " >&6
17487 17487 else
17488 17488 if test -n "$PKGHANDLER"; then
17489 17489 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
17490 17490 else
17491 17491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17492 17492 for as_dir in $PATH
17493 17493 do
17494 17494 IFS=$as_save_IFS
17495 17495 test -z "$as_dir" && as_dir=.
17496 17496 for ac_exec_ext in '' $ac_executable_extensions; do
17497 17497 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17498 17498 ac_cv_prog_PKGHANDLER="$ac_prog"
17499 17499 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17500 17500 break 2
17501 17501 fi
17502 17502 done
17503 17503 done
17504 17504 IFS=$as_save_IFS
17505 17505
17506 17506 fi
17507 17507 fi
17508 17508 PKGHANDLER=$ac_cv_prog_PKGHANDLER
17509 17509 if test -n "$PKGHANDLER"; then
17510 17510 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
17511 17511 $as_echo "$PKGHANDLER" >&6; }
17512 17512 else
17513 17513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17514 17514 $as_echo "no" >&6; }
17515 17515 fi
17516 17516
17517 17517
17518 17518 test -n "$PKGHANDLER" && break
17519 17519 done
17520 17520
17521 17521
17522 17522
17523 17523 # Setup tools that requires more complex handling, or that is not needed by the configure script.
17524 17524
17525 17525
17526 17526
17527 17527 # Publish this variable in the help.
17528 17528
17529 17529
17530 17530 if [ -z "${MAKE+x}" ]; then
17531 17531 # The variable is not set by user, try to locate tool using the code snippet
17532 17532
17533 17533 # Try our hardest to locate a correct version of GNU make
17534 17534 for ac_prog in gmake
17535 17535 do
17536 17536 # Extract the first word of "$ac_prog", so it can be a program name with args.
17537 17537 set dummy $ac_prog; ac_word=$2
17538 17538 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17539 17539 $as_echo_n "checking for $ac_word... " >&6; }
17540 17540 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
17541 17541 $as_echo_n "(cached) " >&6
17542 17542 else
17543 17543 case $CHECK_GMAKE in
17544 17544 [\\/]* | ?:[\\/]*)
17545 17545 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
17546 17546 ;;
17547 17547 *)
17548 17548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17549 17549 for as_dir in $PATH
17550 17550 do
17551 17551 IFS=$as_save_IFS
17552 17552 test -z "$as_dir" && as_dir=.
17553 17553 for ac_exec_ext in '' $ac_executable_extensions; do
17554 17554 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17555 17555 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17556 17556 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17557 17557 break 2
17558 17558 fi
17559 17559 done
17560 17560 done
17561 17561 IFS=$as_save_IFS
17562 17562
17563 17563 ;;
17564 17564 esac
17565 17565 fi
17566 17566 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
17567 17567 if test -n "$CHECK_GMAKE"; then
17568 17568 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
17569 17569 $as_echo "$CHECK_GMAKE" >&6; }
17570 17570 else
17571 17571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17572 17572 $as_echo "no" >&6; }
17573 17573 fi
17574 17574
17575 17575
17576 17576 test -n "$CHECK_GMAKE" && break
17577 17577 done
17578 17578
17579 17579
17580 17580 MAKE_CANDIDATE=""$CHECK_GMAKE""
17581 17581 DESCRIPTION="gmake in PATH"
17582 17582
17583 17583 # On Cygwin, we require a newer version of make than on other platforms
17584 17584 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17585 17585 MAKE_VERSION_EXPR="-e 4\."
17586 17586 MAKE_REQUIRED_VERSION="4.0"
17587 17587 else
17588 17588 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17589 17589 MAKE_REQUIRED_VERSION="3.81"
17590 17590 fi
17591 17591
17592 17592 if test "x$MAKE_CANDIDATE" != x; then
17593 17593 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17594 17594 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17595 17595 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17596 17596 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17597 17597 if test "x$IS_GNU_MAKE" = x; then
17598 17598 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17599 17599 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17600 17600 else
17601 17601 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17602 17602 if test "x$IS_MODERN_MAKE" = x; then
17603 17603 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17604 17604 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17605 17605 else
17606 17606 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17607 17607 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17608 17608 MAKE_EXPECTED_ENV='cygwin'
17609 17609 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17610 17610 MAKE_EXPECTED_ENV='msys'
17611 17611 else
17612 17612 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17613 17613 fi
17614 17614 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17615 17615 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17616 17616 else
17617 17617 # Not relevant for non-Windows
17618 17618 IS_MAKE_CORRECT_ENV=true
17619 17619 fi
17620 17620 if test "x$IS_MAKE_CORRECT_ENV" = x; then
17621 17621 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
17622 17622 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
17623 17623 else
17624 17624 FOUND_MAKE=$MAKE_CANDIDATE
17625 17625
17626 17626 # Only process if variable expands to non-empty
17627 17627
17628 17628 if test "x$FOUND_MAKE" != x; then
17629 17629 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17630 17630
17631 17631 # First separate the path from the arguments. This will split at the first
17632 17632 # space.
17633 17633 complete="$FOUND_MAKE"
17634 17634 path="${complete%% *}"
17635 17635 tmp="$complete EOL"
17636 17636 arguments="${tmp#* }"
17637 17637
17638 17638 # Input might be given as Windows format, start by converting to
17639 17639 # unix format.
17640 17640 new_path=`$CYGPATH -u "$path"`
17641 17641
17642 17642 # Now try to locate executable using which
17643 17643 new_path=`$WHICH "$new_path" 2> /dev/null`
17644 17644 # bat and cmd files are not always considered executable in cygwin causing which
17645 17645 # to not find them
17646 17646 if test "x$new_path" = x \
17647 17647 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17648 17648 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17649 17649 new_path=`$CYGPATH -u "$path"`
17650 17650 fi
17651 17651 if test "x$new_path" = x; then
17652 17652 # Oops. Which didn't find the executable.
17653 17653 # The splitting of arguments from the executable at a space might have been incorrect,
17654 17654 # since paths with space are more likely in Windows. Give it another try with the whole
17655 17655 # argument.
17656 17656 path="$complete"
17657 17657 arguments="EOL"
17658 17658 new_path=`$CYGPATH -u "$path"`
17659 17659 new_path=`$WHICH "$new_path" 2> /dev/null`
17660 17660 # bat and cmd files are not always considered executable in cygwin causing which
17661 17661 # to not find them
17662 17662 if test "x$new_path" = x \
17663 17663 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17664 17664 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17665 17665 new_path=`$CYGPATH -u "$path"`
17666 17666 fi
17667 17667 if test "x$new_path" = x; then
17668 17668 # It's still not found. Now this is an unrecoverable error.
17669 17669 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17670 17670 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17671 17671 has_space=`$ECHO "$complete" | $GREP " "`
17672 17672 if test "x$has_space" != x; then
17673 17673 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17674 17674 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17675 17675 fi
17676 17676 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17677 17677 fi
17678 17678 fi
17679 17679
17680 17680 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17681 17681 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17682 17682 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17683 17683 # "foo.exe" is OK but "foo" is an error.
17684 17684 #
17685 17685 # This test is therefore slightly more accurate than "test -f" to check for file presence.
17686 17686 # It is also a way to make sure we got the proper file name for the real test later on.
17687 17687 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17688 17688 if test "x$test_shortpath" = x; then
17689 17689 # Short path failed, file does not exist as specified.
17690 17690 # Try adding .exe or .cmd
17691 17691 if test -f "${new_path}.exe"; then
17692 17692 input_to_shortpath="${new_path}.exe"
17693 17693 elif test -f "${new_path}.cmd"; then
17694 17694 input_to_shortpath="${new_path}.cmd"
17695 17695 else
17696 17696 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17697 17697 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17698 17698 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17699 17699 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17700 17700 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17701 17701 fi
17702 17702 else
17703 17703 input_to_shortpath="$new_path"
17704 17704 fi
17705 17705
17706 17706 # Call helper function which possibly converts this using DOS-style short mode.
17707 17707 # If so, the updated path is stored in $new_path.
17708 17708 new_path="$input_to_shortpath"
17709 17709
17710 17710 input_path="$input_to_shortpath"
17711 17711 # Check if we need to convert this using DOS-style short mode. If the path
17712 17712 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17713 17713 # take no chances and rewrite it.
17714 17714 # Note: m4 eats our [], so we need to use [ and ] instead.
17715 17715 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17716 17716 if test "x$has_forbidden_chars" != x; then
17717 17717 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17718 17718 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17719 17719 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17720 17720 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17721 17721 # Going to short mode and back again did indeed matter. Since short mode is
17722 17722 # case insensitive, let's make it lowercase to improve readability.
17723 17723 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17724 17724 # Now convert it back to Unix-style (cygpath)
17725 17725 input_path=`$CYGPATH -u "$shortmode_path"`
17726 17726 new_path="$input_path"
17727 17727 fi
17728 17728 fi
17729 17729
17730 17730 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17731 17731 if test "x$test_cygdrive_prefix" = x; then
17732 17732 # As a simple fix, exclude /usr/bin since it's not a real path.
17733 17733 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17734 17734 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17735 17735 # a path prefixed by /cygdrive for fixpath to work.
17736 17736 new_path="$CYGWIN_ROOT_PATH$input_path"
17737 17737 fi
17738 17738 fi
17739 17739
17740 17740 # remove trailing .exe if any
17741 17741 new_path="${new_path/%.exe/}"
17742 17742
17743 17743 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17744 17744
17745 17745 # First separate the path from the arguments. This will split at the first
17746 17746 # space.
17747 17747 complete="$FOUND_MAKE"
17748 17748 path="${complete%% *}"
17749 17749 tmp="$complete EOL"
17750 17750 arguments="${tmp#* }"
17751 17751
17752 17752 # Input might be given as Windows format, start by converting to
17753 17753 # unix format.
17754 17754 new_path="$path"
17755 17755
17756 17756 windows_path="$new_path"
17757 17757 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17758 17758 unix_path=`$CYGPATH -u "$windows_path"`
17759 17759 new_path="$unix_path"
17760 17760 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17761 17761 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17762 17762 new_path="$unix_path"
17763 17763 fi
17764 17764
17765 17765
17766 17766 # Now try to locate executable using which
17767 17767 new_path=`$WHICH "$new_path" 2> /dev/null`
17768 17768
17769 17769 if test "x$new_path" = x; then
17770 17770 # Oops. Which didn't find the executable.
17771 17771 # The splitting of arguments from the executable at a space might have been incorrect,
17772 17772 # since paths with space are more likely in Windows. Give it another try with the whole
17773 17773 # argument.
17774 17774 path="$complete"
17775 17775 arguments="EOL"
17776 17776 new_path="$path"
17777 17777
17778 17778 windows_path="$new_path"
17779 17779 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17780 17780 unix_path=`$CYGPATH -u "$windows_path"`
17781 17781 new_path="$unix_path"
17782 17782 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17783 17783 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17784 17784 new_path="$unix_path"
17785 17785 fi
17786 17786
17787 17787
17788 17788 new_path=`$WHICH "$new_path" 2> /dev/null`
17789 17789 # bat and cmd files are not always considered executable in MSYS causing which
17790 17790 # to not find them
17791 17791 if test "x$new_path" = x \
17792 17792 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17793 17793 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17794 17794 new_path="$path"
17795 17795
17796 17796 windows_path="$new_path"
17797 17797 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17798 17798 unix_path=`$CYGPATH -u "$windows_path"`
17799 17799 new_path="$unix_path"
17800 17800 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17801 17801 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17802 17802 new_path="$unix_path"
17803 17803 fi
17804 17804
17805 17805 fi
17806 17806
17807 17807 if test "x$new_path" = x; then
17808 17808 # It's still not found. Now this is an unrecoverable error.
17809 17809 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17810 17810 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17811 17811 has_space=`$ECHO "$complete" | $GREP " "`
17812 17812 if test "x$has_space" != x; then
17813 17813 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17814 17814 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17815 17815 fi
17816 17816 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17817 17817 fi
17818 17818 fi
17819 17819
17820 17820 # Now new_path has a complete unix path to the binary
17821 17821 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17822 17822 # Keep paths in /bin as-is, but remove trailing .exe if any
17823 17823 new_path="${new_path/%.exe/}"
17824 17824 # Do not save /bin paths to all_fixpath_prefixes!
17825 17825 else
17826 17826 # Not in mixed or Windows style, start by that.
17827 17827 new_path=`cmd //c echo $new_path`
17828 17828
17829 17829 input_path="$new_path"
17830 17830 # Check if we need to convert this using DOS-style short mode. If the path
17831 17831 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17832 17832 # take no chances and rewrite it.
17833 17833 # Note: m4 eats our [], so we need to use [ and ] instead.
17834 17834 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17835 17835 if test "x$has_forbidden_chars" != x; then
17836 17836 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17837 17837 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17838 17838 fi
17839 17839
17840 17840 # Output is in $new_path
17841 17841
17842 17842 windows_path="$new_path"
17843 17843 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17844 17844 unix_path=`$CYGPATH -u "$windows_path"`
17845 17845 new_path="$unix_path"
17846 17846 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17847 17847 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17848 17848 new_path="$unix_path"
17849 17849 fi
17850 17850
17851 17851 # remove trailing .exe if any
17852 17852 new_path="${new_path/%.exe/}"
17853 17853
17854 17854 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17855 17855 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17856 17856 fi
17857 17857
17858 17858 else
17859 17859 # We're on a unix platform. Hooray! :)
17860 17860 # First separate the path from the arguments. This will split at the first
17861 17861 # space.
17862 17862 complete="$FOUND_MAKE"
17863 17863 path="${complete%% *}"
17864 17864 tmp="$complete EOL"
17865 17865 arguments="${tmp#* }"
17866 17866
17867 17867 # Cannot rely on the command "which" here since it doesn't always work.
17868 17868 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17869 17869 if test -z "$is_absolute_path"; then
17870 17870 # Path to executable is not absolute. Find it.
17871 17871 IFS_save="$IFS"
17872 17872 IFS=:
17873 17873 for p in $PATH; do
17874 17874 if test -f "$p/$path" && test -x "$p/$path"; then
17875 17875 new_path="$p/$path"
17876 17876 break
17877 17877 fi
17878 17878 done
17879 17879 IFS="$IFS_save"
17880 17880 else
17881 17881 # This is an absolute path, we can use it without further modifications.
17882 17882 new_path="$path"
17883 17883 fi
17884 17884
17885 17885 if test "x$new_path" = x; then
17886 17886 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17887 17887 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17888 17888 has_space=`$ECHO "$complete" | $GREP " "`
17889 17889 if test "x$has_space" != x; then
17890 17890 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17891 17891 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17892 17892 fi
17893 17893 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17894 17894 fi
17895 17895 fi
17896 17896
17897 17897 # Now join together the path and the arguments once again
17898 17898 if test "x$arguments" != xEOL; then
17899 17899 new_complete="$new_path ${arguments% *}"
17900 17900 else
17901 17901 new_complete="$new_path"
17902 17902 fi
17903 17903
17904 17904 if test "x$complete" != "x$new_complete"; then
17905 17905 FOUND_MAKE="$new_complete"
17906 17906 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17907 17907 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17908 17908 fi
17909 17909 fi
17910 17910
17911 17911 fi
17912 17912 fi
17913 17913 fi
17914 17914 fi
17915 17915
17916 17916
17917 17917 if test "x$FOUND_MAKE" = x; then
17918 17918 for ac_prog in make
17919 17919 do
17920 17920 # Extract the first word of "$ac_prog", so it can be a program name with args.
17921 17921 set dummy $ac_prog; ac_word=$2
17922 17922 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17923 17923 $as_echo_n "checking for $ac_word... " >&6; }
17924 17924 if ${ac_cv_path_CHECK_MAKE+:} false; then :
17925 17925 $as_echo_n "(cached) " >&6
17926 17926 else
17927 17927 case $CHECK_MAKE in
17928 17928 [\\/]* | ?:[\\/]*)
17929 17929 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17930 17930 ;;
17931 17931 *)
17932 17932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17933 17933 for as_dir in $PATH
17934 17934 do
17935 17935 IFS=$as_save_IFS
17936 17936 test -z "$as_dir" && as_dir=.
17937 17937 for ac_exec_ext in '' $ac_executable_extensions; do
17938 17938 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17939 17939 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17940 17940 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17941 17941 break 2
17942 17942 fi
17943 17943 done
17944 17944 done
17945 17945 IFS=$as_save_IFS
17946 17946
17947 17947 ;;
17948 17948 esac
17949 17949 fi
17950 17950 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17951 17951 if test -n "$CHECK_MAKE"; then
17952 17952 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17953 17953 $as_echo "$CHECK_MAKE" >&6; }
17954 17954 else
17955 17955 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17956 17956 $as_echo "no" >&6; }
17957 17957 fi
17958 17958
17959 17959
17960 17960 test -n "$CHECK_MAKE" && break
17961 17961 done
17962 17962
17963 17963
17964 17964 MAKE_CANDIDATE=""$CHECK_MAKE""
17965 17965 DESCRIPTION="make in PATH"
17966 17966
17967 17967 # On Cygwin, we require a newer version of make than on other platforms
17968 17968 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17969 17969 MAKE_VERSION_EXPR="-e 4\."
17970 17970 MAKE_REQUIRED_VERSION="4.0"
17971 17971 else
17972 17972 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17973 17973 MAKE_REQUIRED_VERSION="3.81"
17974 17974 fi
17975 17975
17976 17976 if test "x$MAKE_CANDIDATE" != x; then
17977 17977 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17978 17978 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17979 17979 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17980 17980 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17981 17981 if test "x$IS_GNU_MAKE" = x; then
17982 17982 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17983 17983 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17984 17984 else
17985 17985 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17986 17986 if test "x$IS_MODERN_MAKE" = x; then
17987 17987 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17988 17988 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17989 17989 else
17990 17990 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17991 17991 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17992 17992 MAKE_EXPECTED_ENV='cygwin'
17993 17993 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17994 17994 MAKE_EXPECTED_ENV='msys'
17995 17995 else
17996 17996 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17997 17997 fi
17998 17998 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17999 17999 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18000 18000 else
18001 18001 # Not relevant for non-Windows
18002 18002 IS_MAKE_CORRECT_ENV=true
18003 18003 fi
18004 18004 if test "x$IS_MAKE_CORRECT_ENV" = x; then
18005 18005 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
18006 18006 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
18007 18007 else
18008 18008 FOUND_MAKE=$MAKE_CANDIDATE
18009 18009
18010 18010 # Only process if variable expands to non-empty
18011 18011
18012 18012 if test "x$FOUND_MAKE" != x; then
18013 18013 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18014 18014
18015 18015 # First separate the path from the arguments. This will split at the first
18016 18016 # space.
18017 18017 complete="$FOUND_MAKE"
18018 18018 path="${complete%% *}"
18019 18019 tmp="$complete EOL"
18020 18020 arguments="${tmp#* }"
18021 18021
18022 18022 # Input might be given as Windows format, start by converting to
18023 18023 # unix format.
18024 18024 new_path=`$CYGPATH -u "$path"`
18025 18025
18026 18026 # Now try to locate executable using which
18027 18027 new_path=`$WHICH "$new_path" 2> /dev/null`
18028 18028 # bat and cmd files are not always considered executable in cygwin causing which
18029 18029 # to not find them
18030 18030 if test "x$new_path" = x \
18031 18031 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18032 18032 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18033 18033 new_path=`$CYGPATH -u "$path"`
18034 18034 fi
18035 18035 if test "x$new_path" = x; then
18036 18036 # Oops. Which didn't find the executable.
18037 18037 # The splitting of arguments from the executable at a space might have been incorrect,
18038 18038 # since paths with space are more likely in Windows. Give it another try with the whole
18039 18039 # argument.
18040 18040 path="$complete"
18041 18041 arguments="EOL"
18042 18042 new_path=`$CYGPATH -u "$path"`
18043 18043 new_path=`$WHICH "$new_path" 2> /dev/null`
18044 18044 # bat and cmd files are not always considered executable in cygwin causing which
18045 18045 # to not find them
18046 18046 if test "x$new_path" = x \
18047 18047 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18048 18048 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18049 18049 new_path=`$CYGPATH -u "$path"`
18050 18050 fi
18051 18051 if test "x$new_path" = x; then
18052 18052 # It's still not found. Now this is an unrecoverable error.
18053 18053 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18054 18054 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18055 18055 has_space=`$ECHO "$complete" | $GREP " "`
18056 18056 if test "x$has_space" != x; then
18057 18057 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18058 18058 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18059 18059 fi
18060 18060 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18061 18061 fi
18062 18062 fi
18063 18063
18064 18064 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18065 18065 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18066 18066 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18067 18067 # "foo.exe" is OK but "foo" is an error.
18068 18068 #
18069 18069 # This test is therefore slightly more accurate than "test -f" to check for file presence.
18070 18070 # It is also a way to make sure we got the proper file name for the real test later on.
18071 18071 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18072 18072 if test "x$test_shortpath" = x; then
18073 18073 # Short path failed, file does not exist as specified.
18074 18074 # Try adding .exe or .cmd
18075 18075 if test -f "${new_path}.exe"; then
18076 18076 input_to_shortpath="${new_path}.exe"
18077 18077 elif test -f "${new_path}.cmd"; then
18078 18078 input_to_shortpath="${new_path}.cmd"
18079 18079 else
18080 18080 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18081 18081 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18082 18082 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18083 18083 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18084 18084 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18085 18085 fi
18086 18086 else
18087 18087 input_to_shortpath="$new_path"
18088 18088 fi
18089 18089
18090 18090 # Call helper function which possibly converts this using DOS-style short mode.
18091 18091 # If so, the updated path is stored in $new_path.
18092 18092 new_path="$input_to_shortpath"
18093 18093
18094 18094 input_path="$input_to_shortpath"
18095 18095 # Check if we need to convert this using DOS-style short mode. If the path
18096 18096 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18097 18097 # take no chances and rewrite it.
18098 18098 # Note: m4 eats our [], so we need to use [ and ] instead.
18099 18099 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18100 18100 if test "x$has_forbidden_chars" != x; then
18101 18101 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18102 18102 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18103 18103 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18104 18104 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18105 18105 # Going to short mode and back again did indeed matter. Since short mode is
18106 18106 # case insensitive, let's make it lowercase to improve readability.
18107 18107 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18108 18108 # Now convert it back to Unix-style (cygpath)
18109 18109 input_path=`$CYGPATH -u "$shortmode_path"`
18110 18110 new_path="$input_path"
18111 18111 fi
18112 18112 fi
18113 18113
18114 18114 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18115 18115 if test "x$test_cygdrive_prefix" = x; then
18116 18116 # As a simple fix, exclude /usr/bin since it's not a real path.
18117 18117 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18118 18118 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18119 18119 # a path prefixed by /cygdrive for fixpath to work.
18120 18120 new_path="$CYGWIN_ROOT_PATH$input_path"
18121 18121 fi
18122 18122 fi
18123 18123
18124 18124 # remove trailing .exe if any
18125 18125 new_path="${new_path/%.exe/}"
18126 18126
18127 18127 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18128 18128
18129 18129 # First separate the path from the arguments. This will split at the first
18130 18130 # space.
18131 18131 complete="$FOUND_MAKE"
18132 18132 path="${complete%% *}"
18133 18133 tmp="$complete EOL"
18134 18134 arguments="${tmp#* }"
18135 18135
18136 18136 # Input might be given as Windows format, start by converting to
18137 18137 # unix format.
18138 18138 new_path="$path"
18139 18139
18140 18140 windows_path="$new_path"
18141 18141 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18142 18142 unix_path=`$CYGPATH -u "$windows_path"`
18143 18143 new_path="$unix_path"
18144 18144 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18145 18145 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18146 18146 new_path="$unix_path"
18147 18147 fi
18148 18148
18149 18149
18150 18150 # Now try to locate executable using which
18151 18151 new_path=`$WHICH "$new_path" 2> /dev/null`
18152 18152
18153 18153 if test "x$new_path" = x; then
18154 18154 # Oops. Which didn't find the executable.
18155 18155 # The splitting of arguments from the executable at a space might have been incorrect,
18156 18156 # since paths with space are more likely in Windows. Give it another try with the whole
18157 18157 # argument.
18158 18158 path="$complete"
18159 18159 arguments="EOL"
18160 18160 new_path="$path"
18161 18161
18162 18162 windows_path="$new_path"
18163 18163 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18164 18164 unix_path=`$CYGPATH -u "$windows_path"`
18165 18165 new_path="$unix_path"
18166 18166 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18167 18167 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18168 18168 new_path="$unix_path"
18169 18169 fi
18170 18170
18171 18171
18172 18172 new_path=`$WHICH "$new_path" 2> /dev/null`
18173 18173 # bat and cmd files are not always considered executable in MSYS causing which
18174 18174 # to not find them
18175 18175 if test "x$new_path" = x \
18176 18176 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18177 18177 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18178 18178 new_path="$path"
18179 18179
18180 18180 windows_path="$new_path"
18181 18181 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18182 18182 unix_path=`$CYGPATH -u "$windows_path"`
18183 18183 new_path="$unix_path"
18184 18184 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18185 18185 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18186 18186 new_path="$unix_path"
18187 18187 fi
18188 18188
18189 18189 fi
18190 18190
18191 18191 if test "x$new_path" = x; then
18192 18192 # It's still not found. Now this is an unrecoverable error.
18193 18193 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18194 18194 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18195 18195 has_space=`$ECHO "$complete" | $GREP " "`
18196 18196 if test "x$has_space" != x; then
18197 18197 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18198 18198 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18199 18199 fi
18200 18200 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18201 18201 fi
18202 18202 fi
18203 18203
18204 18204 # Now new_path has a complete unix path to the binary
18205 18205 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18206 18206 # Keep paths in /bin as-is, but remove trailing .exe if any
18207 18207 new_path="${new_path/%.exe/}"
18208 18208 # Do not save /bin paths to all_fixpath_prefixes!
18209 18209 else
18210 18210 # Not in mixed or Windows style, start by that.
18211 18211 new_path=`cmd //c echo $new_path`
18212 18212
18213 18213 input_path="$new_path"
18214 18214 # Check if we need to convert this using DOS-style short mode. If the path
18215 18215 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18216 18216 # take no chances and rewrite it.
18217 18217 # Note: m4 eats our [], so we need to use [ and ] instead.
18218 18218 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18219 18219 if test "x$has_forbidden_chars" != x; then
18220 18220 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18221 18221 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18222 18222 fi
18223 18223
18224 18224 # Output is in $new_path
18225 18225
18226 18226 windows_path="$new_path"
18227 18227 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18228 18228 unix_path=`$CYGPATH -u "$windows_path"`
18229 18229 new_path="$unix_path"
18230 18230 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18231 18231 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18232 18232 new_path="$unix_path"
18233 18233 fi
18234 18234
18235 18235 # remove trailing .exe if any
18236 18236 new_path="${new_path/%.exe/}"
18237 18237
18238 18238 # Save the first 10 bytes of this path to the storage, so fixpath can work.
18239 18239 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18240 18240 fi
18241 18241
18242 18242 else
18243 18243 # We're on a unix platform. Hooray! :)
18244 18244 # First separate the path from the arguments. This will split at the first
18245 18245 # space.
18246 18246 complete="$FOUND_MAKE"
18247 18247 path="${complete%% *}"
18248 18248 tmp="$complete EOL"
18249 18249 arguments="${tmp#* }"
18250 18250
18251 18251 # Cannot rely on the command "which" here since it doesn't always work.
18252 18252 is_absolute_path=`$ECHO "$path" | $GREP ^/`
18253 18253 if test -z "$is_absolute_path"; then
18254 18254 # Path to executable is not absolute. Find it.
18255 18255 IFS_save="$IFS"
18256 18256 IFS=:
18257 18257 for p in $PATH; do
18258 18258 if test -f "$p/$path" && test -x "$p/$path"; then
18259 18259 new_path="$p/$path"
18260 18260 break
18261 18261 fi
18262 18262 done
18263 18263 IFS="$IFS_save"
18264 18264 else
18265 18265 # This is an absolute path, we can use it without further modifications.
18266 18266 new_path="$path"
18267 18267 fi
18268 18268
18269 18269 if test "x$new_path" = x; then
18270 18270 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18271 18271 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18272 18272 has_space=`$ECHO "$complete" | $GREP " "`
18273 18273 if test "x$has_space" != x; then
18274 18274 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18275 18275 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18276 18276 fi
18277 18277 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18278 18278 fi
18279 18279 fi
18280 18280
18281 18281 # Now join together the path and the arguments once again
18282 18282 if test "x$arguments" != xEOL; then
18283 18283 new_complete="$new_path ${arguments% *}"
18284 18284 else
18285 18285 new_complete="$new_path"
18286 18286 fi
18287 18287
18288 18288 if test "x$complete" != "x$new_complete"; then
18289 18289 FOUND_MAKE="$new_complete"
18290 18290 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18291 18291 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18292 18292 fi
18293 18293 fi
18294 18294
18295 18295 fi
18296 18296 fi
18297 18297 fi
18298 18298 fi
18299 18299
18300 18300 fi
18301 18301
18302 18302 if test "x$FOUND_MAKE" = x; then
18303 18303 if test "x$TOOLCHAIN_PATH" != x; then
18304 18304 # We have a toolchain path, check that as well before giving up.
18305 18305 OLD_PATH=$PATH
18306 18306 PATH=$TOOLCHAIN_PATH:$PATH
18307 18307 for ac_prog in gmake
18308 18308 do
18309 18309 # Extract the first word of "$ac_prog", so it can be a program name with args.
18310 18310 set dummy $ac_prog; ac_word=$2
18311 18311 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18312 18312 $as_echo_n "checking for $ac_word... " >&6; }
18313 18313 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
18314 18314 $as_echo_n "(cached) " >&6
18315 18315 else
18316 18316 case $CHECK_TOOLSDIR_GMAKE in
18317 18317 [\\/]* | ?:[\\/]*)
18318 18318 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
18319 18319 ;;
18320 18320 *)
18321 18321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18322 18322 for as_dir in $PATH
18323 18323 do
18324 18324 IFS=$as_save_IFS
18325 18325 test -z "$as_dir" && as_dir=.
18326 18326 for ac_exec_ext in '' $ac_executable_extensions; do
18327 18327 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18328 18328 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18329 18329 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18330 18330 break 2
18331 18331 fi
18332 18332 done
18333 18333 done
18334 18334 IFS=$as_save_IFS
18335 18335
18336 18336 ;;
18337 18337 esac
18338 18338 fi
18339 18339 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
18340 18340 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
18341 18341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
18342 18342 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
18343 18343 else
18344 18344 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18345 18345 $as_echo "no" >&6; }
18346 18346 fi
18347 18347
18348 18348
18349 18349 test -n "$CHECK_TOOLSDIR_GMAKE" && break
18350 18350 done
18351 18351
18352 18352
18353 18353 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
18354 18354 DESCRIPTION="gmake in tools-dir"
18355 18355
18356 18356 # On Cygwin, we require a newer version of make than on other platforms
18357 18357 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18358 18358 MAKE_VERSION_EXPR="-e 4\."
18359 18359 MAKE_REQUIRED_VERSION="4.0"
18360 18360 else
18361 18361 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18362 18362 MAKE_REQUIRED_VERSION="3.81"
18363 18363 fi
18364 18364
18365 18365 if test "x$MAKE_CANDIDATE" != x; then
18366 18366 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18367 18367 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18368 18368 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18369 18369 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18370 18370 if test "x$IS_GNU_MAKE" = x; then
18371 18371 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18372 18372 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18373 18373 else
18374 18374 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18375 18375 if test "x$IS_MODERN_MAKE" = x; then
18376 18376 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
18377 18377 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
18378 18378 else
18379 18379 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18380 18380 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18381 18381 MAKE_EXPECTED_ENV='cygwin'
18382 18382 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18383 18383 MAKE_EXPECTED_ENV='msys'
18384 18384 else
18385 18385 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18386 18386 fi
18387 18387 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18388 18388 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18389 18389 else
18390 18390 # Not relevant for non-Windows
18391 18391 IS_MAKE_CORRECT_ENV=true
18392 18392 fi
18393 18393 if test "x$IS_MAKE_CORRECT_ENV" = x; then
18394 18394 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
18395 18395 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
18396 18396 else
18397 18397 FOUND_MAKE=$MAKE_CANDIDATE
18398 18398
18399 18399 # Only process if variable expands to non-empty
18400 18400
18401 18401 if test "x$FOUND_MAKE" != x; then
18402 18402 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18403 18403
18404 18404 # First separate the path from the arguments. This will split at the first
18405 18405 # space.
18406 18406 complete="$FOUND_MAKE"
18407 18407 path="${complete%% *}"
18408 18408 tmp="$complete EOL"
18409 18409 arguments="${tmp#* }"
18410 18410
18411 18411 # Input might be given as Windows format, start by converting to
18412 18412 # unix format.
18413 18413 new_path=`$CYGPATH -u "$path"`
18414 18414
18415 18415 # Now try to locate executable using which
18416 18416 new_path=`$WHICH "$new_path" 2> /dev/null`
18417 18417 # bat and cmd files are not always considered executable in cygwin causing which
18418 18418 # to not find them
18419 18419 if test "x$new_path" = x \
18420 18420 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18421 18421 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18422 18422 new_path=`$CYGPATH -u "$path"`
18423 18423 fi
18424 18424 if test "x$new_path" = x; then
18425 18425 # Oops. Which didn't find the executable.
18426 18426 # The splitting of arguments from the executable at a space might have been incorrect,
18427 18427 # since paths with space are more likely in Windows. Give it another try with the whole
18428 18428 # argument.
18429 18429 path="$complete"
18430 18430 arguments="EOL"
18431 18431 new_path=`$CYGPATH -u "$path"`
18432 18432 new_path=`$WHICH "$new_path" 2> /dev/null`
18433 18433 # bat and cmd files are not always considered executable in cygwin causing which
18434 18434 # to not find them
18435 18435 if test "x$new_path" = x \
18436 18436 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18437 18437 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18438 18438 new_path=`$CYGPATH -u "$path"`
18439 18439 fi
18440 18440 if test "x$new_path" = x; then
18441 18441 # It's still not found. Now this is an unrecoverable error.
18442 18442 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18443 18443 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18444 18444 has_space=`$ECHO "$complete" | $GREP " "`
18445 18445 if test "x$has_space" != x; then
18446 18446 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18447 18447 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18448 18448 fi
18449 18449 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18450 18450 fi
18451 18451 fi
18452 18452
18453 18453 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18454 18454 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18455 18455 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18456 18456 # "foo.exe" is OK but "foo" is an error.
18457 18457 #
18458 18458 # This test is therefore slightly more accurate than "test -f" to check for file presence.
18459 18459 # It is also a way to make sure we got the proper file name for the real test later on.
18460 18460 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18461 18461 if test "x$test_shortpath" = x; then
18462 18462 # Short path failed, file does not exist as specified.
18463 18463 # Try adding .exe or .cmd
18464 18464 if test -f "${new_path}.exe"; then
18465 18465 input_to_shortpath="${new_path}.exe"
18466 18466 elif test -f "${new_path}.cmd"; then
18467 18467 input_to_shortpath="${new_path}.cmd"
18468 18468 else
18469 18469 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18470 18470 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18471 18471 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18472 18472 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18473 18473 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18474 18474 fi
18475 18475 else
18476 18476 input_to_shortpath="$new_path"
18477 18477 fi
18478 18478
18479 18479 # Call helper function which possibly converts this using DOS-style short mode.
18480 18480 # If so, the updated path is stored in $new_path.
18481 18481 new_path="$input_to_shortpath"
18482 18482
18483 18483 input_path="$input_to_shortpath"
18484 18484 # Check if we need to convert this using DOS-style short mode. If the path
18485 18485 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18486 18486 # take no chances and rewrite it.
18487 18487 # Note: m4 eats our [], so we need to use [ and ] instead.
18488 18488 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18489 18489 if test "x$has_forbidden_chars" != x; then
18490 18490 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18491 18491 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18492 18492 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18493 18493 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18494 18494 # Going to short mode and back again did indeed matter. Since short mode is
18495 18495 # case insensitive, let's make it lowercase to improve readability.
18496 18496 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18497 18497 # Now convert it back to Unix-style (cygpath)
18498 18498 input_path=`$CYGPATH -u "$shortmode_path"`
18499 18499 new_path="$input_path"
18500 18500 fi
18501 18501 fi
18502 18502
18503 18503 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18504 18504 if test "x$test_cygdrive_prefix" = x; then
18505 18505 # As a simple fix, exclude /usr/bin since it's not a real path.
18506 18506 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18507 18507 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18508 18508 # a path prefixed by /cygdrive for fixpath to work.
18509 18509 new_path="$CYGWIN_ROOT_PATH$input_path"
18510 18510 fi
18511 18511 fi
18512 18512
18513 18513 # remove trailing .exe if any
18514 18514 new_path="${new_path/%.exe/}"
18515 18515
18516 18516 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18517 18517
18518 18518 # First separate the path from the arguments. This will split at the first
18519 18519 # space.
18520 18520 complete="$FOUND_MAKE"
18521 18521 path="${complete%% *}"
18522 18522 tmp="$complete EOL"
18523 18523 arguments="${tmp#* }"
18524 18524
18525 18525 # Input might be given as Windows format, start by converting to
18526 18526 # unix format.
18527 18527 new_path="$path"
18528 18528
18529 18529 windows_path="$new_path"
18530 18530 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18531 18531 unix_path=`$CYGPATH -u "$windows_path"`
18532 18532 new_path="$unix_path"
18533 18533 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18534 18534 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18535 18535 new_path="$unix_path"
18536 18536 fi
18537 18537
18538 18538
18539 18539 # Now try to locate executable using which
18540 18540 new_path=`$WHICH "$new_path" 2> /dev/null`
18541 18541
18542 18542 if test "x$new_path" = x; then
18543 18543 # Oops. Which didn't find the executable.
18544 18544 # The splitting of arguments from the executable at a space might have been incorrect,
18545 18545 # since paths with space are more likely in Windows. Give it another try with the whole
18546 18546 # argument.
18547 18547 path="$complete"
18548 18548 arguments="EOL"
18549 18549 new_path="$path"
18550 18550
18551 18551 windows_path="$new_path"
18552 18552 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18553 18553 unix_path=`$CYGPATH -u "$windows_path"`
18554 18554 new_path="$unix_path"
18555 18555 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18556 18556 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18557 18557 new_path="$unix_path"
18558 18558 fi
18559 18559
18560 18560
18561 18561 new_path=`$WHICH "$new_path" 2> /dev/null`
18562 18562 # bat and cmd files are not always considered executable in MSYS causing which
18563 18563 # to not find them
18564 18564 if test "x$new_path" = x \
18565 18565 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18566 18566 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18567 18567 new_path="$path"
18568 18568
18569 18569 windows_path="$new_path"
18570 18570 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18571 18571 unix_path=`$CYGPATH -u "$windows_path"`
18572 18572 new_path="$unix_path"
18573 18573 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18574 18574 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18575 18575 new_path="$unix_path"
18576 18576 fi
18577 18577
18578 18578 fi
18579 18579
18580 18580 if test "x$new_path" = x; then
18581 18581 # It's still not found. Now this is an unrecoverable error.
18582 18582 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18583 18583 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18584 18584 has_space=`$ECHO "$complete" | $GREP " "`
18585 18585 if test "x$has_space" != x; then
18586 18586 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18587 18587 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18588 18588 fi
18589 18589 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18590 18590 fi
18591 18591 fi
18592 18592
18593 18593 # Now new_path has a complete unix path to the binary
18594 18594 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18595 18595 # Keep paths in /bin as-is, but remove trailing .exe if any
18596 18596 new_path="${new_path/%.exe/}"
18597 18597 # Do not save /bin paths to all_fixpath_prefixes!
18598 18598 else
18599 18599 # Not in mixed or Windows style, start by that.
18600 18600 new_path=`cmd //c echo $new_path`
18601 18601
18602 18602 input_path="$new_path"
18603 18603 # Check if we need to convert this using DOS-style short mode. If the path
18604 18604 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18605 18605 # take no chances and rewrite it.
18606 18606 # Note: m4 eats our [], so we need to use [ and ] instead.
18607 18607 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18608 18608 if test "x$has_forbidden_chars" != x; then
18609 18609 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18610 18610 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18611 18611 fi
18612 18612
18613 18613 # Output is in $new_path
18614 18614
18615 18615 windows_path="$new_path"
18616 18616 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18617 18617 unix_path=`$CYGPATH -u "$windows_path"`
18618 18618 new_path="$unix_path"
18619 18619 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18620 18620 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18621 18621 new_path="$unix_path"
18622 18622 fi
18623 18623
18624 18624 # remove trailing .exe if any
18625 18625 new_path="${new_path/%.exe/}"
18626 18626
18627 18627 # Save the first 10 bytes of this path to the storage, so fixpath can work.
18628 18628 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18629 18629 fi
18630 18630
18631 18631 else
18632 18632 # We're on a unix platform. Hooray! :)
18633 18633 # First separate the path from the arguments. This will split at the first
18634 18634 # space.
18635 18635 complete="$FOUND_MAKE"
18636 18636 path="${complete%% *}"
18637 18637 tmp="$complete EOL"
18638 18638 arguments="${tmp#* }"
18639 18639
18640 18640 # Cannot rely on the command "which" here since it doesn't always work.
18641 18641 is_absolute_path=`$ECHO "$path" | $GREP ^/`
18642 18642 if test -z "$is_absolute_path"; then
18643 18643 # Path to executable is not absolute. Find it.
18644 18644 IFS_save="$IFS"
18645 18645 IFS=:
18646 18646 for p in $PATH; do
18647 18647 if test -f "$p/$path" && test -x "$p/$path"; then
18648 18648 new_path="$p/$path"
18649 18649 break
18650 18650 fi
18651 18651 done
18652 18652 IFS="$IFS_save"
18653 18653 else
18654 18654 # This is an absolute path, we can use it without further modifications.
18655 18655 new_path="$path"
18656 18656 fi
18657 18657
18658 18658 if test "x$new_path" = x; then
18659 18659 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18660 18660 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18661 18661 has_space=`$ECHO "$complete" | $GREP " "`
18662 18662 if test "x$has_space" != x; then
18663 18663 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18664 18664 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18665 18665 fi
18666 18666 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18667 18667 fi
18668 18668 fi
18669 18669
18670 18670 # Now join together the path and the arguments once again
18671 18671 if test "x$arguments" != xEOL; then
18672 18672 new_complete="$new_path ${arguments% *}"
18673 18673 else
18674 18674 new_complete="$new_path"
18675 18675 fi
18676 18676
18677 18677 if test "x$complete" != "x$new_complete"; then
18678 18678 FOUND_MAKE="$new_complete"
18679 18679 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18680 18680 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18681 18681 fi
18682 18682 fi
18683 18683
18684 18684 fi
18685 18685 fi
18686 18686 fi
18687 18687 fi
18688 18688
18689 18689 if test "x$FOUND_MAKE" = x; then
18690 18690 for ac_prog in make
18691 18691 do
18692 18692 # Extract the first word of "$ac_prog", so it can be a program name with args.
18693 18693 set dummy $ac_prog; ac_word=$2
18694 18694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18695 18695 $as_echo_n "checking for $ac_word... " >&6; }
18696 18696 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
18697 18697 $as_echo_n "(cached) " >&6
18698 18698 else
18699 18699 case $CHECK_TOOLSDIR_MAKE in
18700 18700 [\\/]* | ?:[\\/]*)
18701 18701 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
18702 18702 ;;
18703 18703 *)
18704 18704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18705 18705 for as_dir in $PATH
18706 18706 do
18707 18707 IFS=$as_save_IFS
18708 18708 test -z "$as_dir" && as_dir=.
18709 18709 for ac_exec_ext in '' $ac_executable_extensions; do
18710 18710 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18711 18711 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
18712 18712 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18713 18713 break 2
18714 18714 fi
18715 18715 done
18716 18716 done
18717 18717 IFS=$as_save_IFS
18718 18718
18719 18719 ;;
18720 18720 esac
18721 18721 fi
18722 18722 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
18723 18723 if test -n "$CHECK_TOOLSDIR_MAKE"; then
18724 18724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
18725 18725 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
18726 18726 else
18727 18727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18728 18728 $as_echo "no" >&6; }
18729 18729 fi
18730 18730
18731 18731
18732 18732 test -n "$CHECK_TOOLSDIR_MAKE" && break
18733 18733 done
18734 18734
18735 18735
18736 18736 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
18737 18737 DESCRIPTION="make in tools-dir"
18738 18738
18739 18739 # On Cygwin, we require a newer version of make than on other platforms
18740 18740 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18741 18741 MAKE_VERSION_EXPR="-e 4\."
18742 18742 MAKE_REQUIRED_VERSION="4.0"
18743 18743 else
18744 18744 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18745 18745 MAKE_REQUIRED_VERSION="3.81"
18746 18746 fi
18747 18747
18748 18748 if test "x$MAKE_CANDIDATE" != x; then
18749 18749 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18750 18750 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18751 18751 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18752 18752 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18753 18753 if test "x$IS_GNU_MAKE" = x; then
18754 18754 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18755 18755 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18756 18756 else
18757 18757 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18758 18758 if test "x$IS_MODERN_MAKE" = x; then
18759 18759 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
18760 18760 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
18761 18761 else
18762 18762 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18763 18763 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18764 18764 MAKE_EXPECTED_ENV='cygwin'
18765 18765 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18766 18766 MAKE_EXPECTED_ENV='msys'
18767 18767 else
18768 18768 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18769 18769 fi
18770 18770 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18771 18771 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18772 18772 else
18773 18773 # Not relevant for non-Windows
18774 18774 IS_MAKE_CORRECT_ENV=true
18775 18775 fi
18776 18776 if test "x$IS_MAKE_CORRECT_ENV" = x; then
18777 18777 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
18778 18778 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
18779 18779 else
18780 18780 FOUND_MAKE=$MAKE_CANDIDATE
18781 18781
18782 18782 # Only process if variable expands to non-empty
18783 18783
18784 18784 if test "x$FOUND_MAKE" != x; then
18785 18785 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18786 18786
18787 18787 # First separate the path from the arguments. This will split at the first
18788 18788 # space.
18789 18789 complete="$FOUND_MAKE"
18790 18790 path="${complete%% *}"
18791 18791 tmp="$complete EOL"
18792 18792 arguments="${tmp#* }"
18793 18793
18794 18794 # Input might be given as Windows format, start by converting to
18795 18795 # unix format.
18796 18796 new_path=`$CYGPATH -u "$path"`
18797 18797
18798 18798 # Now try to locate executable using which
18799 18799 new_path=`$WHICH "$new_path" 2> /dev/null`
18800 18800 # bat and cmd files are not always considered executable in cygwin causing which
18801 18801 # to not find them
18802 18802 if test "x$new_path" = x \
18803 18803 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18804 18804 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18805 18805 new_path=`$CYGPATH -u "$path"`
18806 18806 fi
18807 18807 if test "x$new_path" = x; then
18808 18808 # Oops. Which didn't find the executable.
18809 18809 # The splitting of arguments from the executable at a space might have been incorrect,
18810 18810 # since paths with space are more likely in Windows. Give it another try with the whole
18811 18811 # argument.
18812 18812 path="$complete"
18813 18813 arguments="EOL"
18814 18814 new_path=`$CYGPATH -u "$path"`
18815 18815 new_path=`$WHICH "$new_path" 2> /dev/null`
18816 18816 # bat and cmd files are not always considered executable in cygwin causing which
18817 18817 # to not find them
18818 18818 if test "x$new_path" = x \
18819 18819 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18820 18820 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18821 18821 new_path=`$CYGPATH -u "$path"`
18822 18822 fi
18823 18823 if test "x$new_path" = x; then
18824 18824 # It's still not found. Now this is an unrecoverable error.
18825 18825 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18826 18826 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18827 18827 has_space=`$ECHO "$complete" | $GREP " "`
18828 18828 if test "x$has_space" != x; then
18829 18829 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18830 18830 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18831 18831 fi
18832 18832 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18833 18833 fi
18834 18834 fi
18835 18835
18836 18836 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18837 18837 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18838 18838 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18839 18839 # "foo.exe" is OK but "foo" is an error.
18840 18840 #
18841 18841 # This test is therefore slightly more accurate than "test -f" to check for file presence.
18842 18842 # It is also a way to make sure we got the proper file name for the real test later on.
18843 18843 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18844 18844 if test "x$test_shortpath" = x; then
18845 18845 # Short path failed, file does not exist as specified.
18846 18846 # Try adding .exe or .cmd
18847 18847 if test -f "${new_path}.exe"; then
18848 18848 input_to_shortpath="${new_path}.exe"
18849 18849 elif test -f "${new_path}.cmd"; then
18850 18850 input_to_shortpath="${new_path}.cmd"
18851 18851 else
18852 18852 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18853 18853 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18854 18854 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18855 18855 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18856 18856 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18857 18857 fi
18858 18858 else
18859 18859 input_to_shortpath="$new_path"
18860 18860 fi
18861 18861
18862 18862 # Call helper function which possibly converts this using DOS-style short mode.
18863 18863 # If so, the updated path is stored in $new_path.
18864 18864 new_path="$input_to_shortpath"
18865 18865
18866 18866 input_path="$input_to_shortpath"
18867 18867 # Check if we need to convert this using DOS-style short mode. If the path
18868 18868 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18869 18869 # take no chances and rewrite it.
18870 18870 # Note: m4 eats our [], so we need to use [ and ] instead.
18871 18871 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18872 18872 if test "x$has_forbidden_chars" != x; then
18873 18873 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18874 18874 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18875 18875 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18876 18876 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18877 18877 # Going to short mode and back again did indeed matter. Since short mode is
18878 18878 # case insensitive, let's make it lowercase to improve readability.
18879 18879 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18880 18880 # Now convert it back to Unix-style (cygpath)
18881 18881 input_path=`$CYGPATH -u "$shortmode_path"`
18882 18882 new_path="$input_path"
18883 18883 fi
18884 18884 fi
18885 18885
18886 18886 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18887 18887 if test "x$test_cygdrive_prefix" = x; then
18888 18888 # As a simple fix, exclude /usr/bin since it's not a real path.
18889 18889 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18890 18890 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18891 18891 # a path prefixed by /cygdrive for fixpath to work.
18892 18892 new_path="$CYGWIN_ROOT_PATH$input_path"
18893 18893 fi
18894 18894 fi
18895 18895
18896 18896 # remove trailing .exe if any
18897 18897 new_path="${new_path/%.exe/}"
18898 18898
18899 18899 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18900 18900
18901 18901 # First separate the path from the arguments. This will split at the first
18902 18902 # space.
18903 18903 complete="$FOUND_MAKE"
18904 18904 path="${complete%% *}"
18905 18905 tmp="$complete EOL"
18906 18906 arguments="${tmp#* }"
18907 18907
18908 18908 # Input might be given as Windows format, start by converting to
18909 18909 # unix format.
18910 18910 new_path="$path"
18911 18911
18912 18912 windows_path="$new_path"
18913 18913 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18914 18914 unix_path=`$CYGPATH -u "$windows_path"`
18915 18915 new_path="$unix_path"
18916 18916 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18917 18917 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18918 18918 new_path="$unix_path"
18919 18919 fi
18920 18920
18921 18921
18922 18922 # Now try to locate executable using which
18923 18923 new_path=`$WHICH "$new_path" 2> /dev/null`
18924 18924
18925 18925 if test "x$new_path" = x; then
18926 18926 # Oops. Which didn't find the executable.
18927 18927 # The splitting of arguments from the executable at a space might have been incorrect,
18928 18928 # since paths with space are more likely in Windows. Give it another try with the whole
18929 18929 # argument.
18930 18930 path="$complete"
18931 18931 arguments="EOL"
18932 18932 new_path="$path"
18933 18933
18934 18934 windows_path="$new_path"
18935 18935 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18936 18936 unix_path=`$CYGPATH -u "$windows_path"`
18937 18937 new_path="$unix_path"
18938 18938 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18939 18939 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18940 18940 new_path="$unix_path"
18941 18941 fi
18942 18942
18943 18943
18944 18944 new_path=`$WHICH "$new_path" 2> /dev/null`
18945 18945 # bat and cmd files are not always considered executable in MSYS causing which
18946 18946 # to not find them
18947 18947 if test "x$new_path" = x \
18948 18948 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18949 18949 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18950 18950 new_path="$path"
18951 18951
18952 18952 windows_path="$new_path"
18953 18953 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18954 18954 unix_path=`$CYGPATH -u "$windows_path"`
18955 18955 new_path="$unix_path"
18956 18956 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18957 18957 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18958 18958 new_path="$unix_path"
18959 18959 fi
18960 18960
18961 18961 fi
18962 18962
18963 18963 if test "x$new_path" = x; then
18964 18964 # It's still not found. Now this is an unrecoverable error.
18965 18965 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18966 18966 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18967 18967 has_space=`$ECHO "$complete" | $GREP " "`
18968 18968 if test "x$has_space" != x; then
18969 18969 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18970 18970 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18971 18971 fi
18972 18972 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18973 18973 fi
18974 18974 fi
18975 18975
18976 18976 # Now new_path has a complete unix path to the binary
18977 18977 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18978 18978 # Keep paths in /bin as-is, but remove trailing .exe if any
18979 18979 new_path="${new_path/%.exe/}"
18980 18980 # Do not save /bin paths to all_fixpath_prefixes!
18981 18981 else
18982 18982 # Not in mixed or Windows style, start by that.
18983 18983 new_path=`cmd //c echo $new_path`
18984 18984
18985 18985 input_path="$new_path"
18986 18986 # Check if we need to convert this using DOS-style short mode. If the path
18987 18987 # contains just simple characters, use it. Otherwise (spaces, weird characters),
18988 18988 # take no chances and rewrite it.
18989 18989 # Note: m4 eats our [], so we need to use [ and ] instead.
18990 18990 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18991 18991 if test "x$has_forbidden_chars" != x; then
18992 18992 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18993 18993 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18994 18994 fi
18995 18995
18996 18996 # Output is in $new_path
18997 18997
18998 18998 windows_path="$new_path"
18999 18999 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19000 19000 unix_path=`$CYGPATH -u "$windows_path"`
19001 19001 new_path="$unix_path"
19002 19002 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19003 19003 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19004 19004 new_path="$unix_path"
19005 19005 fi
19006 19006
19007 19007 # remove trailing .exe if any
19008 19008 new_path="${new_path/%.exe/}"
19009 19009
19010 19010 # Save the first 10 bytes of this path to the storage, so fixpath can work.
19011 19011 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19012 19012 fi
19013 19013
19014 19014 else
19015 19015 # We're on a unix platform. Hooray! :)
19016 19016 # First separate the path from the arguments. This will split at the first
19017 19017 # space.
19018 19018 complete="$FOUND_MAKE"
19019 19019 path="${complete%% *}"
19020 19020 tmp="$complete EOL"
19021 19021 arguments="${tmp#* }"
19022 19022
19023 19023 # Cannot rely on the command "which" here since it doesn't always work.
19024 19024 is_absolute_path=`$ECHO "$path" | $GREP ^/`
19025 19025 if test -z "$is_absolute_path"; then
19026 19026 # Path to executable is not absolute. Find it.
19027 19027 IFS_save="$IFS"
19028 19028 IFS=:
19029 19029 for p in $PATH; do
19030 19030 if test -f "$p/$path" && test -x "$p/$path"; then
19031 19031 new_path="$p/$path"
19032 19032 break
19033 19033 fi
19034 19034 done
19035 19035 IFS="$IFS_save"
19036 19036 else
19037 19037 # This is an absolute path, we can use it without further modifications.
19038 19038 new_path="$path"
19039 19039 fi
19040 19040
19041 19041 if test "x$new_path" = x; then
19042 19042 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19043 19043 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19044 19044 has_space=`$ECHO "$complete" | $GREP " "`
19045 19045 if test "x$has_space" != x; then
19046 19046 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19047 19047 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19048 19048 fi
19049 19049 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19050 19050 fi
19051 19051 fi
19052 19052
19053 19053 # Now join together the path and the arguments once again
19054 19054 if test "x$arguments" != xEOL; then
19055 19055 new_complete="$new_path ${arguments% *}"
19056 19056 else
19057 19057 new_complete="$new_path"
19058 19058 fi
19059 19059
19060 19060 if test "x$complete" != "x$new_complete"; then
19061 19061 FOUND_MAKE="$new_complete"
19062 19062 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19063 19063 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19064 19064 fi
19065 19065 fi
19066 19066
19067 19067 fi
19068 19068 fi
19069 19069 fi
19070 19070 fi
19071 19071
19072 19072 fi
19073 19073 PATH=$OLD_PATH
19074 19074 fi
19075 19075 fi
19076 19076
19077 19077 if test "x$FOUND_MAKE" = x; then
19078 19078 as_fn_error $? "Cannot find GNU make $MAKE_REQUIRED_VERSION or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
19079 19079 fi
19080 19080
19081 19081 else
19082 19082 # The variable is set, but is it from the command line or the environment?
19083 19083
19084 19084 # Try to remove the string !MAKE! from our list.
19085 19085 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
19086 19086 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19087 19087 # If it failed, the variable was not from the command line. Ignore it,
19088 19088 # but warn the user (except for BASH, which is always set by the calling BASH).
19089 19089 if test "xMAKE" != xBASH; then
19090 19090 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
19091 19091 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
19092 19092 fi
19093 19093 # Try to locate tool using the code snippet
19094 19094
19095 19095 # Try our hardest to locate a correct version of GNU make
19096 19096 for ac_prog in gmake
19097 19097 do
19098 19098 # Extract the first word of "$ac_prog", so it can be a program name with args.
19099 19099 set dummy $ac_prog; ac_word=$2
19100 19100 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19101 19101 $as_echo_n "checking for $ac_word... " >&6; }
19102 19102 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
19103 19103 $as_echo_n "(cached) " >&6
19104 19104 else
19105 19105 case $CHECK_GMAKE in
19106 19106 [\\/]* | ?:[\\/]*)
19107 19107 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
19108 19108 ;;
19109 19109 *)
19110 19110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19111 19111 for as_dir in $PATH
19112 19112 do
19113 19113 IFS=$as_save_IFS
19114 19114 test -z "$as_dir" && as_dir=.
19115 19115 for ac_exec_ext in '' $ac_executable_extensions; do
19116 19116 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19117 19117 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19118 19118 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19119 19119 break 2
19120 19120 fi
19121 19121 done
19122 19122 done
19123 19123 IFS=$as_save_IFS
19124 19124
19125 19125 ;;
19126 19126 esac
19127 19127 fi
19128 19128 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
19129 19129 if test -n "$CHECK_GMAKE"; then
19130 19130 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
19131 19131 $as_echo "$CHECK_GMAKE" >&6; }
19132 19132 else
19133 19133 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19134 19134 $as_echo "no" >&6; }
19135 19135 fi
19136 19136
19137 19137
19138 19138 test -n "$CHECK_GMAKE" && break
19139 19139 done
19140 19140
19141 19141
19142 19142 MAKE_CANDIDATE=""$CHECK_GMAKE""
19143 19143 DESCRIPTION="gmake in PATH"
19144 19144
19145 19145 # On Cygwin, we require a newer version of make than on other platforms
19146 19146 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19147 19147 MAKE_VERSION_EXPR="-e 4\."
19148 19148 MAKE_REQUIRED_VERSION="4.0"
19149 19149 else
19150 19150 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19151 19151 MAKE_REQUIRED_VERSION="3.81"
19152 19152 fi
19153 19153
19154 19154 if test "x$MAKE_CANDIDATE" != x; then
19155 19155 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19156 19156 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19157 19157 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19158 19158 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19159 19159 if test "x$IS_GNU_MAKE" = x; then
19160 19160 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19161 19161 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19162 19162 else
19163 19163 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19164 19164 if test "x$IS_MODERN_MAKE" = x; then
19165 19165 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
19166 19166 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
19167 19167 else
19168 19168 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19169 19169 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19170 19170 MAKE_EXPECTED_ENV='cygwin'
19171 19171 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19172 19172 MAKE_EXPECTED_ENV='msys'
19173 19173 else
19174 19174 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19175 19175 fi
19176 19176 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19177 19177 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19178 19178 else
19179 19179 # Not relevant for non-Windows
19180 19180 IS_MAKE_CORRECT_ENV=true
19181 19181 fi
19182 19182 if test "x$IS_MAKE_CORRECT_ENV" = x; then
19183 19183 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
19184 19184 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
19185 19185 else
19186 19186 FOUND_MAKE=$MAKE_CANDIDATE
19187 19187
19188 19188 # Only process if variable expands to non-empty
19189 19189
19190 19190 if test "x$FOUND_MAKE" != x; then
19191 19191 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19192 19192
19193 19193 # First separate the path from the arguments. This will split at the first
19194 19194 # space.
19195 19195 complete="$FOUND_MAKE"
19196 19196 path="${complete%% *}"
19197 19197 tmp="$complete EOL"
19198 19198 arguments="${tmp#* }"
19199 19199
19200 19200 # Input might be given as Windows format, start by converting to
19201 19201 # unix format.
19202 19202 new_path=`$CYGPATH -u "$path"`
19203 19203
19204 19204 # Now try to locate executable using which
19205 19205 new_path=`$WHICH "$new_path" 2> /dev/null`
19206 19206 # bat and cmd files are not always considered executable in cygwin causing which
19207 19207 # to not find them
19208 19208 if test "x$new_path" = x \
19209 19209 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19210 19210 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19211 19211 new_path=`$CYGPATH -u "$path"`
19212 19212 fi
19213 19213 if test "x$new_path" = x; then
19214 19214 # Oops. Which didn't find the executable.
19215 19215 # The splitting of arguments from the executable at a space might have been incorrect,
19216 19216 # since paths with space are more likely in Windows. Give it another try with the whole
19217 19217 # argument.
19218 19218 path="$complete"
19219 19219 arguments="EOL"
19220 19220 new_path=`$CYGPATH -u "$path"`
19221 19221 new_path=`$WHICH "$new_path" 2> /dev/null`
19222 19222 # bat and cmd files are not always considered executable in cygwin causing which
19223 19223 # to not find them
19224 19224 if test "x$new_path" = x \
19225 19225 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19226 19226 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19227 19227 new_path=`$CYGPATH -u "$path"`
19228 19228 fi
19229 19229 if test "x$new_path" = x; then
19230 19230 # It's still not found. Now this is an unrecoverable error.
19231 19231 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19232 19232 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19233 19233 has_space=`$ECHO "$complete" | $GREP " "`
19234 19234 if test "x$has_space" != x; then
19235 19235 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19236 19236 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19237 19237 fi
19238 19238 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19239 19239 fi
19240 19240 fi
19241 19241
19242 19242 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19243 19243 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19244 19244 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19245 19245 # "foo.exe" is OK but "foo" is an error.
19246 19246 #
19247 19247 # This test is therefore slightly more accurate than "test -f" to check for file presence.
19248 19248 # It is also a way to make sure we got the proper file name for the real test later on.
19249 19249 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19250 19250 if test "x$test_shortpath" = x; then
19251 19251 # Short path failed, file does not exist as specified.
19252 19252 # Try adding .exe or .cmd
19253 19253 if test -f "${new_path}.exe"; then
19254 19254 input_to_shortpath="${new_path}.exe"
19255 19255 elif test -f "${new_path}.cmd"; then
19256 19256 input_to_shortpath="${new_path}.cmd"
19257 19257 else
19258 19258 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19259 19259 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19260 19260 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19261 19261 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19262 19262 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19263 19263 fi
19264 19264 else
19265 19265 input_to_shortpath="$new_path"
19266 19266 fi
19267 19267
19268 19268 # Call helper function which possibly converts this using DOS-style short mode.
19269 19269 # If so, the updated path is stored in $new_path.
19270 19270 new_path="$input_to_shortpath"
19271 19271
19272 19272 input_path="$input_to_shortpath"
19273 19273 # Check if we need to convert this using DOS-style short mode. If the path
19274 19274 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19275 19275 # take no chances and rewrite it.
19276 19276 # Note: m4 eats our [], so we need to use [ and ] instead.
19277 19277 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19278 19278 if test "x$has_forbidden_chars" != x; then
19279 19279 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19280 19280 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19281 19281 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19282 19282 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19283 19283 # Going to short mode and back again did indeed matter. Since short mode is
19284 19284 # case insensitive, let's make it lowercase to improve readability.
19285 19285 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19286 19286 # Now convert it back to Unix-style (cygpath)
19287 19287 input_path=`$CYGPATH -u "$shortmode_path"`
19288 19288 new_path="$input_path"
19289 19289 fi
19290 19290 fi
19291 19291
19292 19292 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19293 19293 if test "x$test_cygdrive_prefix" = x; then
19294 19294 # As a simple fix, exclude /usr/bin since it's not a real path.
19295 19295 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19296 19296 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19297 19297 # a path prefixed by /cygdrive for fixpath to work.
19298 19298 new_path="$CYGWIN_ROOT_PATH$input_path"
19299 19299 fi
19300 19300 fi
19301 19301
19302 19302 # remove trailing .exe if any
19303 19303 new_path="${new_path/%.exe/}"
19304 19304
19305 19305 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19306 19306
19307 19307 # First separate the path from the arguments. This will split at the first
19308 19308 # space.
19309 19309 complete="$FOUND_MAKE"
19310 19310 path="${complete%% *}"
19311 19311 tmp="$complete EOL"
19312 19312 arguments="${tmp#* }"
19313 19313
19314 19314 # Input might be given as Windows format, start by converting to
19315 19315 # unix format.
19316 19316 new_path="$path"
19317 19317
19318 19318 windows_path="$new_path"
19319 19319 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19320 19320 unix_path=`$CYGPATH -u "$windows_path"`
19321 19321 new_path="$unix_path"
19322 19322 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19323 19323 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19324 19324 new_path="$unix_path"
19325 19325 fi
19326 19326
19327 19327
19328 19328 # Now try to locate executable using which
19329 19329 new_path=`$WHICH "$new_path" 2> /dev/null`
19330 19330
19331 19331 if test "x$new_path" = x; then
19332 19332 # Oops. Which didn't find the executable.
19333 19333 # The splitting of arguments from the executable at a space might have been incorrect,
19334 19334 # since paths with space are more likely in Windows. Give it another try with the whole
19335 19335 # argument.
19336 19336 path="$complete"
19337 19337 arguments="EOL"
19338 19338 new_path="$path"
19339 19339
19340 19340 windows_path="$new_path"
19341 19341 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19342 19342 unix_path=`$CYGPATH -u "$windows_path"`
19343 19343 new_path="$unix_path"
19344 19344 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19345 19345 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19346 19346 new_path="$unix_path"
19347 19347 fi
19348 19348
19349 19349
19350 19350 new_path=`$WHICH "$new_path" 2> /dev/null`
19351 19351 # bat and cmd files are not always considered executable in MSYS causing which
19352 19352 # to not find them
19353 19353 if test "x$new_path" = x \
19354 19354 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19355 19355 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19356 19356 new_path="$path"
19357 19357
19358 19358 windows_path="$new_path"
19359 19359 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19360 19360 unix_path=`$CYGPATH -u "$windows_path"`
19361 19361 new_path="$unix_path"
19362 19362 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19363 19363 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19364 19364 new_path="$unix_path"
19365 19365 fi
19366 19366
19367 19367 fi
19368 19368
19369 19369 if test "x$new_path" = x; then
19370 19370 # It's still not found. Now this is an unrecoverable error.
19371 19371 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19372 19372 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19373 19373 has_space=`$ECHO "$complete" | $GREP " "`
19374 19374 if test "x$has_space" != x; then
19375 19375 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19376 19376 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19377 19377 fi
19378 19378 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19379 19379 fi
19380 19380 fi
19381 19381
19382 19382 # Now new_path has a complete unix path to the binary
19383 19383 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19384 19384 # Keep paths in /bin as-is, but remove trailing .exe if any
19385 19385 new_path="${new_path/%.exe/}"
19386 19386 # Do not save /bin paths to all_fixpath_prefixes!
19387 19387 else
19388 19388 # Not in mixed or Windows style, start by that.
19389 19389 new_path=`cmd //c echo $new_path`
19390 19390
19391 19391 input_path="$new_path"
19392 19392 # Check if we need to convert this using DOS-style short mode. If the path
19393 19393 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19394 19394 # take no chances and rewrite it.
19395 19395 # Note: m4 eats our [], so we need to use [ and ] instead.
19396 19396 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19397 19397 if test "x$has_forbidden_chars" != x; then
19398 19398 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19399 19399 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19400 19400 fi
19401 19401
19402 19402 # Output is in $new_path
19403 19403
19404 19404 windows_path="$new_path"
19405 19405 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19406 19406 unix_path=`$CYGPATH -u "$windows_path"`
19407 19407 new_path="$unix_path"
19408 19408 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19409 19409 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19410 19410 new_path="$unix_path"
19411 19411 fi
19412 19412
19413 19413 # remove trailing .exe if any
19414 19414 new_path="${new_path/%.exe/}"
19415 19415
19416 19416 # Save the first 10 bytes of this path to the storage, so fixpath can work.
19417 19417 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19418 19418 fi
19419 19419
19420 19420 else
19421 19421 # We're on a unix platform. Hooray! :)
19422 19422 # First separate the path from the arguments. This will split at the first
19423 19423 # space.
19424 19424 complete="$FOUND_MAKE"
19425 19425 path="${complete%% *}"
19426 19426 tmp="$complete EOL"
19427 19427 arguments="${tmp#* }"
19428 19428
19429 19429 # Cannot rely on the command "which" here since it doesn't always work.
19430 19430 is_absolute_path=`$ECHO "$path" | $GREP ^/`
19431 19431 if test -z "$is_absolute_path"; then
19432 19432 # Path to executable is not absolute. Find it.
19433 19433 IFS_save="$IFS"
19434 19434 IFS=:
19435 19435 for p in $PATH; do
19436 19436 if test -f "$p/$path" && test -x "$p/$path"; then
19437 19437 new_path="$p/$path"
19438 19438 break
19439 19439 fi
19440 19440 done
19441 19441 IFS="$IFS_save"
19442 19442 else
19443 19443 # This is an absolute path, we can use it without further modifications.
19444 19444 new_path="$path"
19445 19445 fi
19446 19446
19447 19447 if test "x$new_path" = x; then
19448 19448 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19449 19449 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19450 19450 has_space=`$ECHO "$complete" | $GREP " "`
19451 19451 if test "x$has_space" != x; then
19452 19452 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19453 19453 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19454 19454 fi
19455 19455 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19456 19456 fi
19457 19457 fi
19458 19458
19459 19459 # Now join together the path and the arguments once again
19460 19460 if test "x$arguments" != xEOL; then
19461 19461 new_complete="$new_path ${arguments% *}"
19462 19462 else
19463 19463 new_complete="$new_path"
19464 19464 fi
19465 19465
19466 19466 if test "x$complete" != "x$new_complete"; then
19467 19467 FOUND_MAKE="$new_complete"
19468 19468 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19469 19469 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19470 19470 fi
19471 19471 fi
19472 19472
19473 19473 fi
19474 19474 fi
19475 19475 fi
19476 19476 fi
19477 19477
19478 19478
19479 19479 if test "x$FOUND_MAKE" = x; then
19480 19480 for ac_prog in make
19481 19481 do
19482 19482 # Extract the first word of "$ac_prog", so it can be a program name with args.
19483 19483 set dummy $ac_prog; ac_word=$2
19484 19484 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19485 19485 $as_echo_n "checking for $ac_word... " >&6; }
19486 19486 if ${ac_cv_path_CHECK_MAKE+:} false; then :
19487 19487 $as_echo_n "(cached) " >&6
19488 19488 else
19489 19489 case $CHECK_MAKE in
19490 19490 [\\/]* | ?:[\\/]*)
19491 19491 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
19492 19492 ;;
19493 19493 *)
19494 19494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19495 19495 for as_dir in $PATH
19496 19496 do
19497 19497 IFS=$as_save_IFS
19498 19498 test -z "$as_dir" && as_dir=.
19499 19499 for ac_exec_ext in '' $ac_executable_extensions; do
19500 19500 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19501 19501 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
19502 19502 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19503 19503 break 2
19504 19504 fi
19505 19505 done
19506 19506 done
19507 19507 IFS=$as_save_IFS
19508 19508
19509 19509 ;;
19510 19510 esac
19511 19511 fi
19512 19512 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
19513 19513 if test -n "$CHECK_MAKE"; then
19514 19514 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
19515 19515 $as_echo "$CHECK_MAKE" >&6; }
19516 19516 else
19517 19517 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19518 19518 $as_echo "no" >&6; }
19519 19519 fi
19520 19520
19521 19521
19522 19522 test -n "$CHECK_MAKE" && break
19523 19523 done
19524 19524
19525 19525
19526 19526 MAKE_CANDIDATE=""$CHECK_MAKE""
19527 19527 DESCRIPTION="make in PATH"
19528 19528
19529 19529 # On Cygwin, we require a newer version of make than on other platforms
19530 19530 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19531 19531 MAKE_VERSION_EXPR="-e 4\."
19532 19532 MAKE_REQUIRED_VERSION="4.0"
19533 19533 else
19534 19534 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19535 19535 MAKE_REQUIRED_VERSION="3.81"
19536 19536 fi
19537 19537
19538 19538 if test "x$MAKE_CANDIDATE" != x; then
19539 19539 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19540 19540 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19541 19541 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19542 19542 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19543 19543 if test "x$IS_GNU_MAKE" = x; then
19544 19544 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19545 19545 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19546 19546 else
19547 19547 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19548 19548 if test "x$IS_MODERN_MAKE" = x; then
19549 19549 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
19550 19550 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
19551 19551 else
19552 19552 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19553 19553 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19554 19554 MAKE_EXPECTED_ENV='cygwin'
19555 19555 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19556 19556 MAKE_EXPECTED_ENV='msys'
19557 19557 else
19558 19558 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19559 19559 fi
19560 19560 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19561 19561 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19562 19562 else
19563 19563 # Not relevant for non-Windows
19564 19564 IS_MAKE_CORRECT_ENV=true
19565 19565 fi
19566 19566 if test "x$IS_MAKE_CORRECT_ENV" = x; then
19567 19567 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
19568 19568 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
19569 19569 else
19570 19570 FOUND_MAKE=$MAKE_CANDIDATE
19571 19571
19572 19572 # Only process if variable expands to non-empty
19573 19573
19574 19574 if test "x$FOUND_MAKE" != x; then
19575 19575 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19576 19576
19577 19577 # First separate the path from the arguments. This will split at the first
19578 19578 # space.
19579 19579 complete="$FOUND_MAKE"
19580 19580 path="${complete%% *}"
19581 19581 tmp="$complete EOL"
19582 19582 arguments="${tmp#* }"
19583 19583
19584 19584 # Input might be given as Windows format, start by converting to
19585 19585 # unix format.
19586 19586 new_path=`$CYGPATH -u "$path"`
19587 19587
19588 19588 # Now try to locate executable using which
19589 19589 new_path=`$WHICH "$new_path" 2> /dev/null`
19590 19590 # bat and cmd files are not always considered executable in cygwin causing which
19591 19591 # to not find them
19592 19592 if test "x$new_path" = x \
19593 19593 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19594 19594 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19595 19595 new_path=`$CYGPATH -u "$path"`
19596 19596 fi
19597 19597 if test "x$new_path" = x; then
19598 19598 # Oops. Which didn't find the executable.
19599 19599 # The splitting of arguments from the executable at a space might have been incorrect,
19600 19600 # since paths with space are more likely in Windows. Give it another try with the whole
19601 19601 # argument.
19602 19602 path="$complete"
19603 19603 arguments="EOL"
19604 19604 new_path=`$CYGPATH -u "$path"`
19605 19605 new_path=`$WHICH "$new_path" 2> /dev/null`
19606 19606 # bat and cmd files are not always considered executable in cygwin causing which
19607 19607 # to not find them
19608 19608 if test "x$new_path" = x \
19609 19609 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19610 19610 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19611 19611 new_path=`$CYGPATH -u "$path"`
19612 19612 fi
19613 19613 if test "x$new_path" = x; then
19614 19614 # It's still not found. Now this is an unrecoverable error.
19615 19615 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19616 19616 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19617 19617 has_space=`$ECHO "$complete" | $GREP " "`
19618 19618 if test "x$has_space" != x; then
19619 19619 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19620 19620 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19621 19621 fi
19622 19622 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19623 19623 fi
19624 19624 fi
19625 19625
19626 19626 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19627 19627 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19628 19628 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19629 19629 # "foo.exe" is OK but "foo" is an error.
19630 19630 #
19631 19631 # This test is therefore slightly more accurate than "test -f" to check for file presence.
19632 19632 # It is also a way to make sure we got the proper file name for the real test later on.
19633 19633 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19634 19634 if test "x$test_shortpath" = x; then
19635 19635 # Short path failed, file does not exist as specified.
19636 19636 # Try adding .exe or .cmd
19637 19637 if test -f "${new_path}.exe"; then
19638 19638 input_to_shortpath="${new_path}.exe"
19639 19639 elif test -f "${new_path}.cmd"; then
19640 19640 input_to_shortpath="${new_path}.cmd"
19641 19641 else
19642 19642 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19643 19643 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19644 19644 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19645 19645 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19646 19646 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19647 19647 fi
19648 19648 else
19649 19649 input_to_shortpath="$new_path"
19650 19650 fi
19651 19651
19652 19652 # Call helper function which possibly converts this using DOS-style short mode.
19653 19653 # If so, the updated path is stored in $new_path.
19654 19654 new_path="$input_to_shortpath"
19655 19655
19656 19656 input_path="$input_to_shortpath"
19657 19657 # Check if we need to convert this using DOS-style short mode. If the path
19658 19658 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19659 19659 # take no chances and rewrite it.
19660 19660 # Note: m4 eats our [], so we need to use [ and ] instead.
19661 19661 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19662 19662 if test "x$has_forbidden_chars" != x; then
19663 19663 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19664 19664 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19665 19665 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19666 19666 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19667 19667 # Going to short mode and back again did indeed matter. Since short mode is
19668 19668 # case insensitive, let's make it lowercase to improve readability.
19669 19669 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19670 19670 # Now convert it back to Unix-style (cygpath)
19671 19671 input_path=`$CYGPATH -u "$shortmode_path"`
19672 19672 new_path="$input_path"
19673 19673 fi
19674 19674 fi
19675 19675
19676 19676 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19677 19677 if test "x$test_cygdrive_prefix" = x; then
19678 19678 # As a simple fix, exclude /usr/bin since it's not a real path.
19679 19679 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19680 19680 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19681 19681 # a path prefixed by /cygdrive for fixpath to work.
19682 19682 new_path="$CYGWIN_ROOT_PATH$input_path"
19683 19683 fi
19684 19684 fi
19685 19685
19686 19686 # remove trailing .exe if any
19687 19687 new_path="${new_path/%.exe/}"
19688 19688
19689 19689 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19690 19690
19691 19691 # First separate the path from the arguments. This will split at the first
19692 19692 # space.
19693 19693 complete="$FOUND_MAKE"
19694 19694 path="${complete%% *}"
19695 19695 tmp="$complete EOL"
19696 19696 arguments="${tmp#* }"
19697 19697
19698 19698 # Input might be given as Windows format, start by converting to
19699 19699 # unix format.
19700 19700 new_path="$path"
19701 19701
19702 19702 windows_path="$new_path"
19703 19703 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19704 19704 unix_path=`$CYGPATH -u "$windows_path"`
19705 19705 new_path="$unix_path"
19706 19706 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19707 19707 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19708 19708 new_path="$unix_path"
19709 19709 fi
19710 19710
19711 19711
19712 19712 # Now try to locate executable using which
19713 19713 new_path=`$WHICH "$new_path" 2> /dev/null`
19714 19714
19715 19715 if test "x$new_path" = x; then
19716 19716 # Oops. Which didn't find the executable.
19717 19717 # The splitting of arguments from the executable at a space might have been incorrect,
19718 19718 # since paths with space are more likely in Windows. Give it another try with the whole
19719 19719 # argument.
19720 19720 path="$complete"
19721 19721 arguments="EOL"
19722 19722 new_path="$path"
19723 19723
19724 19724 windows_path="$new_path"
19725 19725 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19726 19726 unix_path=`$CYGPATH -u "$windows_path"`
19727 19727 new_path="$unix_path"
19728 19728 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19729 19729 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19730 19730 new_path="$unix_path"
19731 19731 fi
19732 19732
19733 19733
19734 19734 new_path=`$WHICH "$new_path" 2> /dev/null`
19735 19735 # bat and cmd files are not always considered executable in MSYS causing which
19736 19736 # to not find them
19737 19737 if test "x$new_path" = x \
19738 19738 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19739 19739 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19740 19740 new_path="$path"
19741 19741
19742 19742 windows_path="$new_path"
19743 19743 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19744 19744 unix_path=`$CYGPATH -u "$windows_path"`
19745 19745 new_path="$unix_path"
19746 19746 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19747 19747 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19748 19748 new_path="$unix_path"
19749 19749 fi
19750 19750
19751 19751 fi
19752 19752
19753 19753 if test "x$new_path" = x; then
19754 19754 # It's still not found. Now this is an unrecoverable error.
19755 19755 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19756 19756 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19757 19757 has_space=`$ECHO "$complete" | $GREP " "`
19758 19758 if test "x$has_space" != x; then
19759 19759 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19760 19760 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19761 19761 fi
19762 19762 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19763 19763 fi
19764 19764 fi
19765 19765
19766 19766 # Now new_path has a complete unix path to the binary
19767 19767 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19768 19768 # Keep paths in /bin as-is, but remove trailing .exe if any
19769 19769 new_path="${new_path/%.exe/}"
19770 19770 # Do not save /bin paths to all_fixpath_prefixes!
19771 19771 else
19772 19772 # Not in mixed or Windows style, start by that.
19773 19773 new_path=`cmd //c echo $new_path`
19774 19774
19775 19775 input_path="$new_path"
19776 19776 # Check if we need to convert this using DOS-style short mode. If the path
19777 19777 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19778 19778 # take no chances and rewrite it.
19779 19779 # Note: m4 eats our [], so we need to use [ and ] instead.
19780 19780 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19781 19781 if test "x$has_forbidden_chars" != x; then
19782 19782 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19783 19783 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19784 19784 fi
19785 19785
19786 19786 # Output is in $new_path
19787 19787
19788 19788 windows_path="$new_path"
19789 19789 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19790 19790 unix_path=`$CYGPATH -u "$windows_path"`
19791 19791 new_path="$unix_path"
19792 19792 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19793 19793 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19794 19794 new_path="$unix_path"
19795 19795 fi
19796 19796
19797 19797 # remove trailing .exe if any
19798 19798 new_path="${new_path/%.exe/}"
19799 19799
19800 19800 # Save the first 10 bytes of this path to the storage, so fixpath can work.
19801 19801 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19802 19802 fi
19803 19803
19804 19804 else
19805 19805 # We're on a unix platform. Hooray! :)
19806 19806 # First separate the path from the arguments. This will split at the first
19807 19807 # space.
19808 19808 complete="$FOUND_MAKE"
19809 19809 path="${complete%% *}"
19810 19810 tmp="$complete EOL"
19811 19811 arguments="${tmp#* }"
19812 19812
19813 19813 # Cannot rely on the command "which" here since it doesn't always work.
19814 19814 is_absolute_path=`$ECHO "$path" | $GREP ^/`
19815 19815 if test -z "$is_absolute_path"; then
19816 19816 # Path to executable is not absolute. Find it.
19817 19817 IFS_save="$IFS"
19818 19818 IFS=:
19819 19819 for p in $PATH; do
19820 19820 if test -f "$p/$path" && test -x "$p/$path"; then
19821 19821 new_path="$p/$path"
19822 19822 break
19823 19823 fi
19824 19824 done
19825 19825 IFS="$IFS_save"
19826 19826 else
19827 19827 # This is an absolute path, we can use it without further modifications.
19828 19828 new_path="$path"
19829 19829 fi
19830 19830
19831 19831 if test "x$new_path" = x; then
19832 19832 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19833 19833 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19834 19834 has_space=`$ECHO "$complete" | $GREP " "`
19835 19835 if test "x$has_space" != x; then
19836 19836 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19837 19837 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19838 19838 fi
19839 19839 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19840 19840 fi
19841 19841 fi
19842 19842
19843 19843 # Now join together the path and the arguments once again
19844 19844 if test "x$arguments" != xEOL; then
19845 19845 new_complete="$new_path ${arguments% *}"
19846 19846 else
19847 19847 new_complete="$new_path"
19848 19848 fi
19849 19849
19850 19850 if test "x$complete" != "x$new_complete"; then
19851 19851 FOUND_MAKE="$new_complete"
19852 19852 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19853 19853 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19854 19854 fi
19855 19855 fi
19856 19856
19857 19857 fi
19858 19858 fi
19859 19859 fi
19860 19860 fi
19861 19861
19862 19862 fi
19863 19863
19864 19864 if test "x$FOUND_MAKE" = x; then
19865 19865 if test "x$TOOLCHAIN_PATH" != x; then
19866 19866 # We have a toolchain path, check that as well before giving up.
19867 19867 OLD_PATH=$PATH
19868 19868 PATH=$TOOLCHAIN_PATH:$PATH
19869 19869 for ac_prog in gmake
19870 19870 do
19871 19871 # Extract the first word of "$ac_prog", so it can be a program name with args.
19872 19872 set dummy $ac_prog; ac_word=$2
19873 19873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19874 19874 $as_echo_n "checking for $ac_word... " >&6; }
19875 19875 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
19876 19876 $as_echo_n "(cached) " >&6
19877 19877 else
19878 19878 case $CHECK_TOOLSDIR_GMAKE in
19879 19879 [\\/]* | ?:[\\/]*)
19880 19880 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
19881 19881 ;;
19882 19882 *)
19883 19883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19884 19884 for as_dir in $PATH
19885 19885 do
19886 19886 IFS=$as_save_IFS
19887 19887 test -z "$as_dir" && as_dir=.
19888 19888 for ac_exec_ext in '' $ac_executable_extensions; do
19889 19889 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19890 19890 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19891 19891 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19892 19892 break 2
19893 19893 fi
19894 19894 done
19895 19895 done
19896 19896 IFS=$as_save_IFS
19897 19897
19898 19898 ;;
19899 19899 esac
19900 19900 fi
19901 19901 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19902 19902 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19903 19903 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19904 19904 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19905 19905 else
19906 19906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19907 19907 $as_echo "no" >&6; }
19908 19908 fi
19909 19909
19910 19910
19911 19911 test -n "$CHECK_TOOLSDIR_GMAKE" && break
19912 19912 done
19913 19913
19914 19914
19915 19915 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19916 19916 DESCRIPTION="gmake in tools-dir"
19917 19917
19918 19918 # On Cygwin, we require a newer version of make than on other platforms
19919 19919 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19920 19920 MAKE_VERSION_EXPR="-e 4\."
19921 19921 MAKE_REQUIRED_VERSION="4.0"
19922 19922 else
19923 19923 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19924 19924 MAKE_REQUIRED_VERSION="3.81"
19925 19925 fi
19926 19926
19927 19927 if test "x$MAKE_CANDIDATE" != x; then
19928 19928 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19929 19929 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19930 19930 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19931 19931 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19932 19932 if test "x$IS_GNU_MAKE" = x; then
19933 19933 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19934 19934 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19935 19935 else
19936 19936 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19937 19937 if test "x$IS_MODERN_MAKE" = x; then
19938 19938 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
19939 19939 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
19940 19940 else
19941 19941 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19942 19942 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19943 19943 MAKE_EXPECTED_ENV='cygwin'
19944 19944 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19945 19945 MAKE_EXPECTED_ENV='msys'
19946 19946 else
19947 19947 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19948 19948 fi
19949 19949 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19950 19950 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19951 19951 else
19952 19952 # Not relevant for non-Windows
19953 19953 IS_MAKE_CORRECT_ENV=true
19954 19954 fi
19955 19955 if test "x$IS_MAKE_CORRECT_ENV" = x; then
19956 19956 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
19957 19957 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
19958 19958 else
19959 19959 FOUND_MAKE=$MAKE_CANDIDATE
19960 19960
19961 19961 # Only process if variable expands to non-empty
19962 19962
19963 19963 if test "x$FOUND_MAKE" != x; then
19964 19964 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19965 19965
19966 19966 # First separate the path from the arguments. This will split at the first
19967 19967 # space.
19968 19968 complete="$FOUND_MAKE"
19969 19969 path="${complete%% *}"
19970 19970 tmp="$complete EOL"
19971 19971 arguments="${tmp#* }"
19972 19972
19973 19973 # Input might be given as Windows format, start by converting to
19974 19974 # unix format.
19975 19975 new_path=`$CYGPATH -u "$path"`
19976 19976
19977 19977 # Now try to locate executable using which
19978 19978 new_path=`$WHICH "$new_path" 2> /dev/null`
19979 19979 # bat and cmd files are not always considered executable in cygwin causing which
19980 19980 # to not find them
19981 19981 if test "x$new_path" = x \
19982 19982 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19983 19983 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19984 19984 new_path=`$CYGPATH -u "$path"`
19985 19985 fi
19986 19986 if test "x$new_path" = x; then
19987 19987 # Oops. Which didn't find the executable.
19988 19988 # The splitting of arguments from the executable at a space might have been incorrect,
19989 19989 # since paths with space are more likely in Windows. Give it another try with the whole
19990 19990 # argument.
19991 19991 path="$complete"
19992 19992 arguments="EOL"
19993 19993 new_path=`$CYGPATH -u "$path"`
19994 19994 new_path=`$WHICH "$new_path" 2> /dev/null`
19995 19995 # bat and cmd files are not always considered executable in cygwin causing which
19996 19996 # to not find them
19997 19997 if test "x$new_path" = x \
19998 19998 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19999 19999 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20000 20000 new_path=`$CYGPATH -u "$path"`
20001 20001 fi
20002 20002 if test "x$new_path" = x; then
20003 20003 # It's still not found. Now this is an unrecoverable error.
20004 20004 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20005 20005 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20006 20006 has_space=`$ECHO "$complete" | $GREP " "`
20007 20007 if test "x$has_space" != x; then
20008 20008 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20009 20009 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20010 20010 fi
20011 20011 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20012 20012 fi
20013 20013 fi
20014 20014
20015 20015 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20016 20016 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20017 20017 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20018 20018 # "foo.exe" is OK but "foo" is an error.
20019 20019 #
20020 20020 # This test is therefore slightly more accurate than "test -f" to check for file presence.
20021 20021 # It is also a way to make sure we got the proper file name for the real test later on.
20022 20022 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20023 20023 if test "x$test_shortpath" = x; then
20024 20024 # Short path failed, file does not exist as specified.
20025 20025 # Try adding .exe or .cmd
20026 20026 if test -f "${new_path}.exe"; then
20027 20027 input_to_shortpath="${new_path}.exe"
20028 20028 elif test -f "${new_path}.cmd"; then
20029 20029 input_to_shortpath="${new_path}.cmd"
20030 20030 else
20031 20031 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20032 20032 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20033 20033 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20034 20034 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20035 20035 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20036 20036 fi
20037 20037 else
20038 20038 input_to_shortpath="$new_path"
20039 20039 fi
20040 20040
20041 20041 # Call helper function which possibly converts this using DOS-style short mode.
20042 20042 # If so, the updated path is stored in $new_path.
20043 20043 new_path="$input_to_shortpath"
20044 20044
20045 20045 input_path="$input_to_shortpath"
20046 20046 # Check if we need to convert this using DOS-style short mode. If the path
20047 20047 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20048 20048 # take no chances and rewrite it.
20049 20049 # Note: m4 eats our [], so we need to use [ and ] instead.
20050 20050 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20051 20051 if test "x$has_forbidden_chars" != x; then
20052 20052 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20053 20053 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20054 20054 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20055 20055 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20056 20056 # Going to short mode and back again did indeed matter. Since short mode is
20057 20057 # case insensitive, let's make it lowercase to improve readability.
20058 20058 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20059 20059 # Now convert it back to Unix-style (cygpath)
20060 20060 input_path=`$CYGPATH -u "$shortmode_path"`
20061 20061 new_path="$input_path"
20062 20062 fi
20063 20063 fi
20064 20064
20065 20065 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20066 20066 if test "x$test_cygdrive_prefix" = x; then
20067 20067 # As a simple fix, exclude /usr/bin since it's not a real path.
20068 20068 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20069 20069 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20070 20070 # a path prefixed by /cygdrive for fixpath to work.
20071 20071 new_path="$CYGWIN_ROOT_PATH$input_path"
20072 20072 fi
20073 20073 fi
20074 20074
20075 20075 # remove trailing .exe if any
20076 20076 new_path="${new_path/%.exe/}"
20077 20077
20078 20078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20079 20079
20080 20080 # First separate the path from the arguments. This will split at the first
20081 20081 # space.
20082 20082 complete="$FOUND_MAKE"
20083 20083 path="${complete%% *}"
20084 20084 tmp="$complete EOL"
20085 20085 arguments="${tmp#* }"
20086 20086
20087 20087 # Input might be given as Windows format, start by converting to
20088 20088 # unix format.
20089 20089 new_path="$path"
20090 20090
20091 20091 windows_path="$new_path"
20092 20092 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20093 20093 unix_path=`$CYGPATH -u "$windows_path"`
20094 20094 new_path="$unix_path"
20095 20095 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20096 20096 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20097 20097 new_path="$unix_path"
20098 20098 fi
20099 20099
20100 20100
20101 20101 # Now try to locate executable using which
20102 20102 new_path=`$WHICH "$new_path" 2> /dev/null`
20103 20103
20104 20104 if test "x$new_path" = x; then
20105 20105 # Oops. Which didn't find the executable.
20106 20106 # The splitting of arguments from the executable at a space might have been incorrect,
20107 20107 # since paths with space are more likely in Windows. Give it another try with the whole
20108 20108 # argument.
20109 20109 path="$complete"
20110 20110 arguments="EOL"
20111 20111 new_path="$path"
20112 20112
20113 20113 windows_path="$new_path"
20114 20114 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20115 20115 unix_path=`$CYGPATH -u "$windows_path"`
20116 20116 new_path="$unix_path"
20117 20117 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20118 20118 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20119 20119 new_path="$unix_path"
20120 20120 fi
20121 20121
20122 20122
20123 20123 new_path=`$WHICH "$new_path" 2> /dev/null`
20124 20124 # bat and cmd files are not always considered executable in MSYS causing which
20125 20125 # to not find them
20126 20126 if test "x$new_path" = x \
20127 20127 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20128 20128 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20129 20129 new_path="$path"
20130 20130
20131 20131 windows_path="$new_path"
20132 20132 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20133 20133 unix_path=`$CYGPATH -u "$windows_path"`
20134 20134 new_path="$unix_path"
20135 20135 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20136 20136 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20137 20137 new_path="$unix_path"
20138 20138 fi
20139 20139
20140 20140 fi
20141 20141
20142 20142 if test "x$new_path" = x; then
20143 20143 # It's still not found. Now this is an unrecoverable error.
20144 20144 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20145 20145 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20146 20146 has_space=`$ECHO "$complete" | $GREP " "`
20147 20147 if test "x$has_space" != x; then
20148 20148 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20149 20149 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20150 20150 fi
20151 20151 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20152 20152 fi
20153 20153 fi
20154 20154
20155 20155 # Now new_path has a complete unix path to the binary
20156 20156 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20157 20157 # Keep paths in /bin as-is, but remove trailing .exe if any
20158 20158 new_path="${new_path/%.exe/}"
20159 20159 # Do not save /bin paths to all_fixpath_prefixes!
20160 20160 else
20161 20161 # Not in mixed or Windows style, start by that.
20162 20162 new_path=`cmd //c echo $new_path`
20163 20163
20164 20164 input_path="$new_path"
20165 20165 # Check if we need to convert this using DOS-style short mode. If the path
20166 20166 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20167 20167 # take no chances and rewrite it.
20168 20168 # Note: m4 eats our [], so we need to use [ and ] instead.
20169 20169 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20170 20170 if test "x$has_forbidden_chars" != x; then
20171 20171 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20172 20172 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20173 20173 fi
20174 20174
20175 20175 # Output is in $new_path
20176 20176
20177 20177 windows_path="$new_path"
20178 20178 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20179 20179 unix_path=`$CYGPATH -u "$windows_path"`
20180 20180 new_path="$unix_path"
20181 20181 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20182 20182 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20183 20183 new_path="$unix_path"
20184 20184 fi
20185 20185
20186 20186 # remove trailing .exe if any
20187 20187 new_path="${new_path/%.exe/}"
20188 20188
20189 20189 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20190 20190 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20191 20191 fi
20192 20192
20193 20193 else
20194 20194 # We're on a unix platform. Hooray! :)
20195 20195 # First separate the path from the arguments. This will split at the first
20196 20196 # space.
20197 20197 complete="$FOUND_MAKE"
20198 20198 path="${complete%% *}"
20199 20199 tmp="$complete EOL"
20200 20200 arguments="${tmp#* }"
20201 20201
20202 20202 # Cannot rely on the command "which" here since it doesn't always work.
20203 20203 is_absolute_path=`$ECHO "$path" | $GREP ^/`
20204 20204 if test -z "$is_absolute_path"; then
20205 20205 # Path to executable is not absolute. Find it.
20206 20206 IFS_save="$IFS"
20207 20207 IFS=:
20208 20208 for p in $PATH; do
20209 20209 if test -f "$p/$path" && test -x "$p/$path"; then
20210 20210 new_path="$p/$path"
20211 20211 break
20212 20212 fi
20213 20213 done
20214 20214 IFS="$IFS_save"
20215 20215 else
20216 20216 # This is an absolute path, we can use it without further modifications.
20217 20217 new_path="$path"
20218 20218 fi
20219 20219
20220 20220 if test "x$new_path" = x; then
20221 20221 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20222 20222 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20223 20223 has_space=`$ECHO "$complete" | $GREP " "`
20224 20224 if test "x$has_space" != x; then
20225 20225 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20226 20226 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20227 20227 fi
20228 20228 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20229 20229 fi
20230 20230 fi
20231 20231
20232 20232 # Now join together the path and the arguments once again
20233 20233 if test "x$arguments" != xEOL; then
20234 20234 new_complete="$new_path ${arguments% *}"
20235 20235 else
20236 20236 new_complete="$new_path"
20237 20237 fi
20238 20238
20239 20239 if test "x$complete" != "x$new_complete"; then
20240 20240 FOUND_MAKE="$new_complete"
20241 20241 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20242 20242 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20243 20243 fi
20244 20244 fi
20245 20245
20246 20246 fi
20247 20247 fi
20248 20248 fi
20249 20249 fi
20250 20250
20251 20251 if test "x$FOUND_MAKE" = x; then
20252 20252 for ac_prog in make
20253 20253 do
20254 20254 # Extract the first word of "$ac_prog", so it can be a program name with args.
20255 20255 set dummy $ac_prog; ac_word=$2
20256 20256 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20257 20257 $as_echo_n "checking for $ac_word... " >&6; }
20258 20258 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
20259 20259 $as_echo_n "(cached) " >&6
20260 20260 else
20261 20261 case $CHECK_TOOLSDIR_MAKE in
20262 20262 [\\/]* | ?:[\\/]*)
20263 20263 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
20264 20264 ;;
20265 20265 *)
20266 20266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20267 20267 for as_dir in $PATH
20268 20268 do
20269 20269 IFS=$as_save_IFS
20270 20270 test -z "$as_dir" && as_dir=.
20271 20271 for ac_exec_ext in '' $ac_executable_extensions; do
20272 20272 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20273 20273 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
20274 20274 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20275 20275 break 2
20276 20276 fi
20277 20277 done
20278 20278 done
20279 20279 IFS=$as_save_IFS
20280 20280
20281 20281 ;;
20282 20282 esac
20283 20283 fi
20284 20284 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
20285 20285 if test -n "$CHECK_TOOLSDIR_MAKE"; then
20286 20286 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
20287 20287 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
20288 20288 else
20289 20289 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20290 20290 $as_echo "no" >&6; }
20291 20291 fi
20292 20292
20293 20293
20294 20294 test -n "$CHECK_TOOLSDIR_MAKE" && break
20295 20295 done
20296 20296
20297 20297
20298 20298 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
20299 20299 DESCRIPTION="make in tools-dir"
20300 20300
20301 20301 # On Cygwin, we require a newer version of make than on other platforms
20302 20302 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20303 20303 MAKE_VERSION_EXPR="-e 4\."
20304 20304 MAKE_REQUIRED_VERSION="4.0"
20305 20305 else
20306 20306 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20307 20307 MAKE_REQUIRED_VERSION="3.81"
20308 20308 fi
20309 20309
20310 20310 if test "x$MAKE_CANDIDATE" != x; then
20311 20311 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20312 20312 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20313 20313 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20314 20314 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20315 20315 if test "x$IS_GNU_MAKE" = x; then
20316 20316 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20317 20317 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20318 20318 else
20319 20319 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20320 20320 if test "x$IS_MODERN_MAKE" = x; then
20321 20321 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
20322 20322 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
20323 20323 else
20324 20324 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20325 20325 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20326 20326 MAKE_EXPECTED_ENV='cygwin'
20327 20327 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20328 20328 MAKE_EXPECTED_ENV='msys'
20329 20329 else
20330 20330 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20331 20331 fi
20332 20332 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20333 20333 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20334 20334 else
20335 20335 # Not relevant for non-Windows
20336 20336 IS_MAKE_CORRECT_ENV=true
20337 20337 fi
20338 20338 if test "x$IS_MAKE_CORRECT_ENV" = x; then
20339 20339 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
20340 20340 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
20341 20341 else
20342 20342 FOUND_MAKE=$MAKE_CANDIDATE
20343 20343
20344 20344 # Only process if variable expands to non-empty
20345 20345
20346 20346 if test "x$FOUND_MAKE" != x; then
20347 20347 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20348 20348
20349 20349 # First separate the path from the arguments. This will split at the first
20350 20350 # space.
20351 20351 complete="$FOUND_MAKE"
20352 20352 path="${complete%% *}"
20353 20353 tmp="$complete EOL"
20354 20354 arguments="${tmp#* }"
20355 20355
20356 20356 # Input might be given as Windows format, start by converting to
20357 20357 # unix format.
20358 20358 new_path=`$CYGPATH -u "$path"`
20359 20359
20360 20360 # Now try to locate executable using which
20361 20361 new_path=`$WHICH "$new_path" 2> /dev/null`
20362 20362 # bat and cmd files are not always considered executable in cygwin causing which
20363 20363 # to not find them
20364 20364 if test "x$new_path" = x \
20365 20365 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20366 20366 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20367 20367 new_path=`$CYGPATH -u "$path"`
20368 20368 fi
20369 20369 if test "x$new_path" = x; then
20370 20370 # Oops. Which didn't find the executable.
20371 20371 # The splitting of arguments from the executable at a space might have been incorrect,
20372 20372 # since paths with space are more likely in Windows. Give it another try with the whole
20373 20373 # argument.
20374 20374 path="$complete"
20375 20375 arguments="EOL"
20376 20376 new_path=`$CYGPATH -u "$path"`
20377 20377 new_path=`$WHICH "$new_path" 2> /dev/null`
20378 20378 # bat and cmd files are not always considered executable in cygwin causing which
20379 20379 # to not find them
20380 20380 if test "x$new_path" = x \
20381 20381 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20382 20382 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20383 20383 new_path=`$CYGPATH -u "$path"`
20384 20384 fi
20385 20385 if test "x$new_path" = x; then
20386 20386 # It's still not found. Now this is an unrecoverable error.
20387 20387 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20388 20388 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20389 20389 has_space=`$ECHO "$complete" | $GREP " "`
20390 20390 if test "x$has_space" != x; then
20391 20391 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20392 20392 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20393 20393 fi
20394 20394 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20395 20395 fi
20396 20396 fi
20397 20397
20398 20398 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20399 20399 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20400 20400 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20401 20401 # "foo.exe" is OK but "foo" is an error.
20402 20402 #
20403 20403 # This test is therefore slightly more accurate than "test -f" to check for file presence.
20404 20404 # It is also a way to make sure we got the proper file name for the real test later on.
20405 20405 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20406 20406 if test "x$test_shortpath" = x; then
20407 20407 # Short path failed, file does not exist as specified.
20408 20408 # Try adding .exe or .cmd
20409 20409 if test -f "${new_path}.exe"; then
20410 20410 input_to_shortpath="${new_path}.exe"
20411 20411 elif test -f "${new_path}.cmd"; then
20412 20412 input_to_shortpath="${new_path}.cmd"
20413 20413 else
20414 20414 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20415 20415 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20416 20416 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20417 20417 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20418 20418 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20419 20419 fi
20420 20420 else
20421 20421 input_to_shortpath="$new_path"
20422 20422 fi
20423 20423
20424 20424 # Call helper function which possibly converts this using DOS-style short mode.
20425 20425 # If so, the updated path is stored in $new_path.
20426 20426 new_path="$input_to_shortpath"
20427 20427
20428 20428 input_path="$input_to_shortpath"
20429 20429 # Check if we need to convert this using DOS-style short mode. If the path
20430 20430 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20431 20431 # take no chances and rewrite it.
20432 20432 # Note: m4 eats our [], so we need to use [ and ] instead.
20433 20433 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20434 20434 if test "x$has_forbidden_chars" != x; then
20435 20435 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20436 20436 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20437 20437 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20438 20438 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20439 20439 # Going to short mode and back again did indeed matter. Since short mode is
20440 20440 # case insensitive, let's make it lowercase to improve readability.
20441 20441 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20442 20442 # Now convert it back to Unix-style (cygpath)
20443 20443 input_path=`$CYGPATH -u "$shortmode_path"`
20444 20444 new_path="$input_path"
20445 20445 fi
20446 20446 fi
20447 20447
20448 20448 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20449 20449 if test "x$test_cygdrive_prefix" = x; then
20450 20450 # As a simple fix, exclude /usr/bin since it's not a real path.
20451 20451 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20452 20452 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20453 20453 # a path prefixed by /cygdrive for fixpath to work.
20454 20454 new_path="$CYGWIN_ROOT_PATH$input_path"
20455 20455 fi
20456 20456 fi
20457 20457
20458 20458 # remove trailing .exe if any
20459 20459 new_path="${new_path/%.exe/}"
20460 20460
20461 20461 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20462 20462
20463 20463 # First separate the path from the arguments. This will split at the first
20464 20464 # space.
20465 20465 complete="$FOUND_MAKE"
20466 20466 path="${complete%% *}"
20467 20467 tmp="$complete EOL"
20468 20468 arguments="${tmp#* }"
20469 20469
20470 20470 # Input might be given as Windows format, start by converting to
20471 20471 # unix format.
20472 20472 new_path="$path"
20473 20473
20474 20474 windows_path="$new_path"
20475 20475 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20476 20476 unix_path=`$CYGPATH -u "$windows_path"`
20477 20477 new_path="$unix_path"
20478 20478 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20479 20479 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20480 20480 new_path="$unix_path"
20481 20481 fi
20482 20482
20483 20483
20484 20484 # Now try to locate executable using which
20485 20485 new_path=`$WHICH "$new_path" 2> /dev/null`
20486 20486
20487 20487 if test "x$new_path" = x; then
20488 20488 # Oops. Which didn't find the executable.
20489 20489 # The splitting of arguments from the executable at a space might have been incorrect,
20490 20490 # since paths with space are more likely in Windows. Give it another try with the whole
20491 20491 # argument.
20492 20492 path="$complete"
20493 20493 arguments="EOL"
20494 20494 new_path="$path"
20495 20495
20496 20496 windows_path="$new_path"
20497 20497 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20498 20498 unix_path=`$CYGPATH -u "$windows_path"`
20499 20499 new_path="$unix_path"
20500 20500 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20501 20501 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20502 20502 new_path="$unix_path"
20503 20503 fi
20504 20504
20505 20505
20506 20506 new_path=`$WHICH "$new_path" 2> /dev/null`
20507 20507 # bat and cmd files are not always considered executable in MSYS causing which
20508 20508 # to not find them
20509 20509 if test "x$new_path" = x \
20510 20510 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20511 20511 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20512 20512 new_path="$path"
20513 20513
20514 20514 windows_path="$new_path"
20515 20515 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20516 20516 unix_path=`$CYGPATH -u "$windows_path"`
20517 20517 new_path="$unix_path"
20518 20518 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20519 20519 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20520 20520 new_path="$unix_path"
20521 20521 fi
20522 20522
20523 20523 fi
20524 20524
20525 20525 if test "x$new_path" = x; then
20526 20526 # It's still not found. Now this is an unrecoverable error.
20527 20527 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20528 20528 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20529 20529 has_space=`$ECHO "$complete" | $GREP " "`
20530 20530 if test "x$has_space" != x; then
20531 20531 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20532 20532 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20533 20533 fi
20534 20534 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20535 20535 fi
20536 20536 fi
20537 20537
20538 20538 # Now new_path has a complete unix path to the binary
20539 20539 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20540 20540 # Keep paths in /bin as-is, but remove trailing .exe if any
20541 20541 new_path="${new_path/%.exe/}"
20542 20542 # Do not save /bin paths to all_fixpath_prefixes!
20543 20543 else
20544 20544 # Not in mixed or Windows style, start by that.
20545 20545 new_path=`cmd //c echo $new_path`
20546 20546
20547 20547 input_path="$new_path"
20548 20548 # Check if we need to convert this using DOS-style short mode. If the path
20549 20549 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20550 20550 # take no chances and rewrite it.
20551 20551 # Note: m4 eats our [], so we need to use [ and ] instead.
20552 20552 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20553 20553 if test "x$has_forbidden_chars" != x; then
20554 20554 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20555 20555 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20556 20556 fi
20557 20557
20558 20558 # Output is in $new_path
20559 20559
20560 20560 windows_path="$new_path"
20561 20561 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20562 20562 unix_path=`$CYGPATH -u "$windows_path"`
20563 20563 new_path="$unix_path"
20564 20564 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20565 20565 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20566 20566 new_path="$unix_path"
20567 20567 fi
20568 20568
20569 20569 # remove trailing .exe if any
20570 20570 new_path="${new_path/%.exe/}"
20571 20571
20572 20572 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20573 20573 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20574 20574 fi
20575 20575
20576 20576 else
20577 20577 # We're on a unix platform. Hooray! :)
20578 20578 # First separate the path from the arguments. This will split at the first
20579 20579 # space.
20580 20580 complete="$FOUND_MAKE"
20581 20581 path="${complete%% *}"
20582 20582 tmp="$complete EOL"
20583 20583 arguments="${tmp#* }"
20584 20584
20585 20585 # Cannot rely on the command "which" here since it doesn't always work.
20586 20586 is_absolute_path=`$ECHO "$path" | $GREP ^/`
20587 20587 if test -z "$is_absolute_path"; then
20588 20588 # Path to executable is not absolute. Find it.
20589 20589 IFS_save="$IFS"
20590 20590 IFS=:
20591 20591 for p in $PATH; do
20592 20592 if test -f "$p/$path" && test -x "$p/$path"; then
20593 20593 new_path="$p/$path"
20594 20594 break
20595 20595 fi
20596 20596 done
20597 20597 IFS="$IFS_save"
20598 20598 else
20599 20599 # This is an absolute path, we can use it without further modifications.
20600 20600 new_path="$path"
20601 20601 fi
20602 20602
20603 20603 if test "x$new_path" = x; then
20604 20604 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20605 20605 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20606 20606 has_space=`$ECHO "$complete" | $GREP " "`
20607 20607 if test "x$has_space" != x; then
20608 20608 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20609 20609 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20610 20610 fi
20611 20611 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20612 20612 fi
20613 20613 fi
20614 20614
20615 20615 # Now join together the path and the arguments once again
20616 20616 if test "x$arguments" != xEOL; then
20617 20617 new_complete="$new_path ${arguments% *}"
20618 20618 else
20619 20619 new_complete="$new_path"
20620 20620 fi
20621 20621
20622 20622 if test "x$complete" != "x$new_complete"; then
20623 20623 FOUND_MAKE="$new_complete"
20624 20624 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20625 20625 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20626 20626 fi
20627 20627 fi
20628 20628
20629 20629 fi
20630 20630 fi
20631 20631 fi
20632 20632 fi
20633 20633
20634 20634 fi
20635 20635 PATH=$OLD_PATH
20636 20636 fi
20637 20637 fi
20638 20638
20639 20639 if test "x$FOUND_MAKE" = x; then
20640 20640 as_fn_error $? "Cannot find GNU make $MAKE_REQUIRED_VERSION or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
20641 20641 fi
20642 20642
20643 20643 else
20644 20644 # If it succeeded, then it was overridden by the user. We will use it
20645 20645 # for the tool.
20646 20646
20647 20647 # First remove it from the list of overridden variables, so we can test
20648 20648 # for unknown variables in the end.
20649 20649 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20650 20650
20651 20651 # Check if we try to supply an empty value
20652 20652 if test "x$MAKE" = x; then
20653 20653 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
20654 20654 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
20655 20655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20656 20656 $as_echo_n "checking for MAKE... " >&6; }
20657 20657 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20658 20658 $as_echo "disabled" >&6; }
20659 20659 else
20660 20660 # Check if the provided tool contains a complete path.
20661 20661 tool_specified="$MAKE"
20662 20662 tool_basename="${tool_specified##*/}"
20663 20663 if test "x$tool_basename" = "x$tool_specified"; then
20664 20664 # A command without a complete path is provided, search $PATH.
20665 20665 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
20666 20666 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
20667 20667 # Extract the first word of "$tool_basename", so it can be a program name with args.
20668 20668 set dummy $tool_basename; ac_word=$2
20669 20669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20670 20670 $as_echo_n "checking for $ac_word... " >&6; }
20671 20671 if ${ac_cv_path_MAKE+:} false; then :
20672 20672 $as_echo_n "(cached) " >&6
20673 20673 else
20674 20674 case $MAKE in
20675 20675 [\\/]* | ?:[\\/]*)
20676 20676 ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
20677 20677 ;;
20678 20678 *)
20679 20679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20680 20680 for as_dir in $PATH
20681 20681 do
20682 20682 IFS=$as_save_IFS
20683 20683 test -z "$as_dir" && as_dir=.
20684 20684 for ac_exec_ext in '' $ac_executable_extensions; do
20685 20685 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20686 20686 ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
20687 20687 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20688 20688 break 2
20689 20689 fi
20690 20690 done
20691 20691 done
20692 20692 IFS=$as_save_IFS
20693 20693
20694 20694 ;;
20695 20695 esac
20696 20696 fi
20697 20697 MAKE=$ac_cv_path_MAKE
20698 20698 if test -n "$MAKE"; then
20699 20699 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
20700 20700 $as_echo "$MAKE" >&6; }
20701 20701 else
20702 20702 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20703 20703 $as_echo "no" >&6; }
20704 20704 fi
20705 20705
20706 20706
20707 20707 if test "x$MAKE" = x; then
20708 20708 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20709 20709 fi
20710 20710 else
20711 20711 # Otherwise we believe it is a complete path. Use it as it is.
20712 20712 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
20713 20713 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
20714 20714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20715 20715 $as_echo_n "checking for MAKE... " >&6; }
20716 20716 if test ! -x "$tool_specified"; then
20717 20717 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20718 20718 $as_echo "not found" >&6; }
20719 20719 as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
20720 20720 fi
20721 20721 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20722 20722 $as_echo "$tool_specified" >&6; }
20723 20723 fi
20724 20724 fi
20725 20725 fi
20726 20726
20727 20727 # If MAKE was set by user, verify the version
20728 20728
20729 20729 MAKE_CANDIDATE=""$MAKE""
20730 20730 DESCRIPTION="user supplied MAKE=$MAKE"
20731 20731
20732 20732 # On Cygwin, we require a newer version of make than on other platforms
20733 20733 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20734 20734 MAKE_VERSION_EXPR="-e 4\."
20735 20735 MAKE_REQUIRED_VERSION="4.0"
20736 20736 else
20737 20737 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20738 20738 MAKE_REQUIRED_VERSION="3.81"
20739 20739 fi
20740 20740
20741 20741 if test "x$MAKE_CANDIDATE" != x; then
20742 20742 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20743 20743 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20744 20744 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20745 20745 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20746 20746 if test "x$IS_GNU_MAKE" = x; then
20747 20747 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20748 20748 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20749 20749 else
20750 20750 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20751 20751 if test "x$IS_MODERN_MAKE" = x; then
20752 20752 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
20753 20753 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
20754 20754 else
20755 20755 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20756 20756 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20757 20757 MAKE_EXPECTED_ENV='cygwin'
20758 20758 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20759 20759 MAKE_EXPECTED_ENV='msys'
20760 20760 else
20761 20761 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20762 20762 fi
20763 20763 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20764 20764 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20765 20765 else
20766 20766 # Not relevant for non-Windows
20767 20767 IS_MAKE_CORRECT_ENV=true
20768 20768 fi
20769 20769 if test "x$IS_MAKE_CORRECT_ENV" = x; then
20770 20770 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
20771 20771 $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
20772 20772 else
20773 20773 FOUND_MAKE=$MAKE_CANDIDATE
20774 20774
20775 20775 # Only process if variable expands to non-empty
20776 20776
20777 20777 if test "x$FOUND_MAKE" != x; then
20778 20778 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20779 20779
20780 20780 # First separate the path from the arguments. This will split at the first
20781 20781 # space.
20782 20782 complete="$FOUND_MAKE"
20783 20783 path="${complete%% *}"
20784 20784 tmp="$complete EOL"
20785 20785 arguments="${tmp#* }"
20786 20786
20787 20787 # Input might be given as Windows format, start by converting to
20788 20788 # unix format.
20789 20789 new_path=`$CYGPATH -u "$path"`
20790 20790
20791 20791 # Now try to locate executable using which
20792 20792 new_path=`$WHICH "$new_path" 2> /dev/null`
20793 20793 # bat and cmd files are not always considered executable in cygwin causing which
20794 20794 # to not find them
20795 20795 if test "x$new_path" = x \
20796 20796 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20797 20797 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20798 20798 new_path=`$CYGPATH -u "$path"`
20799 20799 fi
20800 20800 if test "x$new_path" = x; then
20801 20801 # Oops. Which didn't find the executable.
20802 20802 # The splitting of arguments from the executable at a space might have been incorrect,
20803 20803 # since paths with space are more likely in Windows. Give it another try with the whole
20804 20804 # argument.
20805 20805 path="$complete"
20806 20806 arguments="EOL"
20807 20807 new_path=`$CYGPATH -u "$path"`
20808 20808 new_path=`$WHICH "$new_path" 2> /dev/null`
20809 20809 # bat and cmd files are not always considered executable in cygwin causing which
20810 20810 # to not find them
20811 20811 if test "x$new_path" = x \
20812 20812 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20813 20813 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20814 20814 new_path=`$CYGPATH -u "$path"`
20815 20815 fi
20816 20816 if test "x$new_path" = x; then
20817 20817 # It's still not found. Now this is an unrecoverable error.
20818 20818 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20819 20819 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20820 20820 has_space=`$ECHO "$complete" | $GREP " "`
20821 20821 if test "x$has_space" != x; then
20822 20822 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20823 20823 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20824 20824 fi
20825 20825 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20826 20826 fi
20827 20827 fi
20828 20828
20829 20829 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20830 20830 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20831 20831 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20832 20832 # "foo.exe" is OK but "foo" is an error.
20833 20833 #
20834 20834 # This test is therefore slightly more accurate than "test -f" to check for file presence.
20835 20835 # It is also a way to make sure we got the proper file name for the real test later on.
20836 20836 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20837 20837 if test "x$test_shortpath" = x; then
20838 20838 # Short path failed, file does not exist as specified.
20839 20839 # Try adding .exe or .cmd
20840 20840 if test -f "${new_path}.exe"; then
20841 20841 input_to_shortpath="${new_path}.exe"
20842 20842 elif test -f "${new_path}.cmd"; then
20843 20843 input_to_shortpath="${new_path}.cmd"
20844 20844 else
20845 20845 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20846 20846 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20847 20847 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20848 20848 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20849 20849 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20850 20850 fi
20851 20851 else
20852 20852 input_to_shortpath="$new_path"
20853 20853 fi
20854 20854
20855 20855 # Call helper function which possibly converts this using DOS-style short mode.
20856 20856 # If so, the updated path is stored in $new_path.
20857 20857 new_path="$input_to_shortpath"
20858 20858
20859 20859 input_path="$input_to_shortpath"
20860 20860 # Check if we need to convert this using DOS-style short mode. If the path
20861 20861 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20862 20862 # take no chances and rewrite it.
20863 20863 # Note: m4 eats our [], so we need to use [ and ] instead.
20864 20864 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20865 20865 if test "x$has_forbidden_chars" != x; then
20866 20866 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20867 20867 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20868 20868 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20869 20869 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20870 20870 # Going to short mode and back again did indeed matter. Since short mode is
20871 20871 # case insensitive, let's make it lowercase to improve readability.
20872 20872 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20873 20873 # Now convert it back to Unix-style (cygpath)
20874 20874 input_path=`$CYGPATH -u "$shortmode_path"`
20875 20875 new_path="$input_path"
20876 20876 fi
20877 20877 fi
20878 20878
20879 20879 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20880 20880 if test "x$test_cygdrive_prefix" = x; then
20881 20881 # As a simple fix, exclude /usr/bin since it's not a real path.
20882 20882 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20883 20883 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20884 20884 # a path prefixed by /cygdrive for fixpath to work.
20885 20885 new_path="$CYGWIN_ROOT_PATH$input_path"
20886 20886 fi
20887 20887 fi
20888 20888
20889 20889 # remove trailing .exe if any
20890 20890 new_path="${new_path/%.exe/}"
20891 20891
20892 20892 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20893 20893
20894 20894 # First separate the path from the arguments. This will split at the first
20895 20895 # space.
20896 20896 complete="$FOUND_MAKE"
20897 20897 path="${complete%% *}"
20898 20898 tmp="$complete EOL"
20899 20899 arguments="${tmp#* }"
20900 20900
20901 20901 # Input might be given as Windows format, start by converting to
20902 20902 # unix format.
20903 20903 new_path="$path"
20904 20904
20905 20905 windows_path="$new_path"
20906 20906 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20907 20907 unix_path=`$CYGPATH -u "$windows_path"`
20908 20908 new_path="$unix_path"
20909 20909 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20910 20910 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20911 20911 new_path="$unix_path"
20912 20912 fi
20913 20913
20914 20914
20915 20915 # Now try to locate executable using which
20916 20916 new_path=`$WHICH "$new_path" 2> /dev/null`
20917 20917
20918 20918 if test "x$new_path" = x; then
20919 20919 # Oops. Which didn't find the executable.
20920 20920 # The splitting of arguments from the executable at a space might have been incorrect,
20921 20921 # since paths with space are more likely in Windows. Give it another try with the whole
20922 20922 # argument.
20923 20923 path="$complete"
20924 20924 arguments="EOL"
20925 20925 new_path="$path"
20926 20926
20927 20927 windows_path="$new_path"
20928 20928 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20929 20929 unix_path=`$CYGPATH -u "$windows_path"`
20930 20930 new_path="$unix_path"
20931 20931 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20932 20932 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20933 20933 new_path="$unix_path"
20934 20934 fi
20935 20935
20936 20936
20937 20937 new_path=`$WHICH "$new_path" 2> /dev/null`
20938 20938 # bat and cmd files are not always considered executable in MSYS causing which
20939 20939 # to not find them
20940 20940 if test "x$new_path" = x \
20941 20941 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20942 20942 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20943 20943 new_path="$path"
20944 20944
20945 20945 windows_path="$new_path"
20946 20946 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20947 20947 unix_path=`$CYGPATH -u "$windows_path"`
20948 20948 new_path="$unix_path"
20949 20949 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20950 20950 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20951 20951 new_path="$unix_path"
20952 20952 fi
20953 20953
20954 20954 fi
20955 20955
20956 20956 if test "x$new_path" = x; then
20957 20957 # It's still not found. Now this is an unrecoverable error.
20958 20958 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20959 20959 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20960 20960 has_space=`$ECHO "$complete" | $GREP " "`
20961 20961 if test "x$has_space" != x; then
20962 20962 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20963 20963 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20964 20964 fi
20965 20965 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20966 20966 fi
20967 20967 fi
20968 20968
20969 20969 # Now new_path has a complete unix path to the binary
20970 20970 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20971 20971 # Keep paths in /bin as-is, but remove trailing .exe if any
20972 20972 new_path="${new_path/%.exe/}"
20973 20973 # Do not save /bin paths to all_fixpath_prefixes!
20974 20974 else
20975 20975 # Not in mixed or Windows style, start by that.
20976 20976 new_path=`cmd //c echo $new_path`
20977 20977
20978 20978 input_path="$new_path"
20979 20979 # Check if we need to convert this using DOS-style short mode. If the path
20980 20980 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20981 20981 # take no chances and rewrite it.
20982 20982 # Note: m4 eats our [], so we need to use [ and ] instead.
20983 20983 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20984 20984 if test "x$has_forbidden_chars" != x; then
20985 20985 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20986 20986 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20987 20987 fi
20988 20988
20989 20989 # Output is in $new_path
20990 20990
20991 20991 windows_path="$new_path"
20992 20992 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20993 20993 unix_path=`$CYGPATH -u "$windows_path"`
20994 20994 new_path="$unix_path"
20995 20995 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20996 20996 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20997 20997 new_path="$unix_path"
20998 20998 fi
20999 20999
21000 21000 # remove trailing .exe if any
21001 21001 new_path="${new_path/%.exe/}"
21002 21002
21003 21003 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21004 21004 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21005 21005 fi
21006 21006
21007 21007 else
21008 21008 # We're on a unix platform. Hooray! :)
21009 21009 # First separate the path from the arguments. This will split at the first
21010 21010 # space.
21011 21011 complete="$FOUND_MAKE"
21012 21012 path="${complete%% *}"
21013 21013 tmp="$complete EOL"
21014 21014 arguments="${tmp#* }"
21015 21015
21016 21016 # Cannot rely on the command "which" here since it doesn't always work.
21017 21017 is_absolute_path=`$ECHO "$path" | $GREP ^/`
21018 21018 if test -z "$is_absolute_path"; then
21019 21019 # Path to executable is not absolute. Find it.
21020 21020 IFS_save="$IFS"
21021 21021 IFS=:
21022 21022 for p in $PATH; do
21023 21023 if test -f "$p/$path" && test -x "$p/$path"; then
21024 21024 new_path="$p/$path"
21025 21025 break
21026 21026 fi
21027 21027 done
21028 21028 IFS="$IFS_save"
21029 21029 else
21030 21030 # This is an absolute path, we can use it without further modifications.
21031 21031 new_path="$path"
21032 21032 fi
21033 21033
21034 21034 if test "x$new_path" = x; then
21035 21035 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
21036 21036 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
21037 21037 has_space=`$ECHO "$complete" | $GREP " "`
21038 21038 if test "x$has_space" != x; then
21039 21039 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
21040 21040 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
21041 21041 fi
21042 21042 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
21043 21043 fi
21044 21044 fi
21045 21045
21046 21046 # Now join together the path and the arguments once again
21047 21047 if test "x$arguments" != xEOL; then
21048 21048 new_complete="$new_path ${arguments% *}"
21049 21049 else
21050 21050 new_complete="$new_path"
21051 21051 fi
21052 21052
21053 21053 if test "x$complete" != "x$new_complete"; then
21054 21054 FOUND_MAKE="$new_complete"
21055 21055 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
21056 21056 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
21057 21057 fi
21058 21058 fi
21059 21059
21060 21060 fi
21061 21061 fi
21062 21062 fi
21063 21063 fi
21064 21064
21065 21065 if test "x$FOUND_MAKE" = x; then
21066 21066 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
21067 21067 fi
21068 21068
21069 21069 fi
21070 21070
21071 21071
21072 21072 MAKE=$FOUND_MAKE
21073 21073
21074 21074 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
21075 21075 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
21076 21076
21077 21077
21078 21078 # Check if make supports the output sync option and if so, setup using it.
21079 21079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
21080 21080 $as_echo_n "checking if make --output-sync is supported... " >&6; }
21081 21081 if $MAKE --version -O > /dev/null 2>&1; then
21082 21082 OUTPUT_SYNC_SUPPORTED=true
21083 21083 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21084 21084 $as_echo "yes" >&6; }
21085 21085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
21086 21086 $as_echo_n "checking for output-sync value... " >&6; }
21087 21087
21088 21088 # Check whether --with-output-sync was given.
21089 21089 if test "${with_output_sync+set}" = set; then :
21090 21090 withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
21091 21091 fi
21092 21092
21093 21093 if test "x$OUTPUT_SYNC" = "x"; then
21094 21094 OUTPUT_SYNC=none
21095 21095 fi
21096 21096 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
21097 21097 $as_echo "$OUTPUT_SYNC" >&6; }
21098 21098 if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
21099 21099 as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
21100 21100 fi
21101 21101 else
21102 21102 OUTPUT_SYNC_SUPPORTED=false
21103 21103 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21104 21104 $as_echo "no" >&6; }
21105 21105 fi
21106 21106
21107 21107
21108 21108
21109 21109
21110 21110
21111 21111
21112 21112 # Test if find supports -delete
21113 21113 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
21114 21114 $as_echo_n "checking if find supports -delete... " >&6; }
21115 21115 FIND_DELETE="-delete"
21116 21116
21117 21117 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
21118 21118
21119 21119 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
21120 21120
21121 21121 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
21122 21122 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
21123 21123 # No, it does not.
21124 21124 $RM $DELETEDIR/TestIfFindSupportsDelete
21125 21125 if test "x$OPENJDK_TARGET_OS" = "xaix"; then
21126 21126 # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
21127 21127 FIND_DELETE="-print | $XARGS $RM"
21128 21128 else
21129 21129 FIND_DELETE="-exec $RM \{\} \+"
21130 21130 fi
21131 21131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21132 21132 $as_echo "no" >&6; }
21133 21133 else
21134 21134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21135 21135 $as_echo "yes" >&6; }
21136 21136 fi
21137 21137 $RMDIR $DELETEDIR
21138 21138
21139 21139
21140 21140
21141 21141 # Test which kind of tar was found
21142 21142 if test "x$($TAR --version | $GREP "GNU tar")" != "x"; then
21143 21143 TAR_TYPE="gnu"
21144 21144 elif test "x$($TAR -v | $GREP "bsdtar")" != "x"; then
21145 21145 TAR_TYPE="bsd"
21146 21146 elif test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
21147 21147 TAR_TYPE="solaris"
21148 21148 fi
21149 21149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of tar was found" >&5
21150 21150 $as_echo_n "checking what type of tar was found... " >&6; }
21151 21151 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR_TYPE" >&5
21152 21152 $as_echo "$TAR_TYPE" >&6; }
21153 21153
21154 21154 TAR_CREATE_FILE_PARAM=""
21155 21155
21156 21156 if test "x$TAR_TYPE" = "xgnu"; then
21157 21157 TAR_INCLUDE_PARAM="T"
21158 21158 TAR_SUPPORTS_TRANSFORM="true"
21159 21159 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
21160 21160 # When using gnu tar for Solaris targets, need to use compatibility mode
21161 21161 TAR_CREATE_EXTRA_PARAM="--format=ustar"
21162 21162 fi
21163 21163 else
21164 21164 TAR_INCLUDE_PARAM="I"
21165 21165 TAR_SUPPORTS_TRANSFORM="false"
21166 21166 fi
21167 21167
21168 21168
21169 21169
21170 21170
21171 21171
21172 21172
21173 21173 # These tools might not be installed by default,
21174 21174 # need hint on how to install them.
21175 21175
21176 21176
21177 21177
21178 21178 # Publish this variable in the help.
21179 21179
21180 21180
21181 21181 if [ -z "${UNZIP+x}" ]; then
21182 21182 # The variable is not set by user, try to locate tool using the code snippet
21183 21183 for ac_prog in unzip
21184 21184 do
21185 21185 # Extract the first word of "$ac_prog", so it can be a program name with args.
21186 21186 set dummy $ac_prog; ac_word=$2
21187 21187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21188 21188 $as_echo_n "checking for $ac_word... " >&6; }
21189 21189 if ${ac_cv_path_UNZIP+:} false; then :
21190 21190 $as_echo_n "(cached) " >&6
21191 21191 else
21192 21192 case $UNZIP in
21193 21193 [\\/]* | ?:[\\/]*)
21194 21194 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21195 21195 ;;
21196 21196 *)
21197 21197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21198 21198 for as_dir in $PATH
21199 21199 do
21200 21200 IFS=$as_save_IFS
21201 21201 test -z "$as_dir" && as_dir=.
21202 21202 for ac_exec_ext in '' $ac_executable_extensions; do
21203 21203 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21204 21204 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21205 21205 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21206 21206 break 2
21207 21207 fi
21208 21208 done
21209 21209 done
21210 21210 IFS=$as_save_IFS
21211 21211
21212 21212 ;;
21213 21213 esac
21214 21214 fi
21215 21215 UNZIP=$ac_cv_path_UNZIP
21216 21216 if test -n "$UNZIP"; then
21217 21217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21218 21218 $as_echo "$UNZIP" >&6; }
21219 21219 else
21220 21220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21221 21221 $as_echo "no" >&6; }
21222 21222 fi
21223 21223
21224 21224
21225 21225 test -n "$UNZIP" && break
21226 21226 done
21227 21227
21228 21228 else
21229 21229 # The variable is set, but is it from the command line or the environment?
21230 21230
21231 21231 # Try to remove the string !UNZIP! from our list.
21232 21232 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
21233 21233 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21234 21234 # If it failed, the variable was not from the command line. Ignore it,
21235 21235 # but warn the user (except for BASH, which is always set by the calling BASH).
21236 21236 if test "xUNZIP" != xBASH; then
21237 21237 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
21238 21238 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
21239 21239 fi
21240 21240 # Try to locate tool using the code snippet
21241 21241 for ac_prog in unzip
21242 21242 do
21243 21243 # Extract the first word of "$ac_prog", so it can be a program name with args.
21244 21244 set dummy $ac_prog; ac_word=$2
21245 21245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21246 21246 $as_echo_n "checking for $ac_word... " >&6; }
21247 21247 if ${ac_cv_path_UNZIP+:} false; then :
21248 21248 $as_echo_n "(cached) " >&6
21249 21249 else
21250 21250 case $UNZIP in
21251 21251 [\\/]* | ?:[\\/]*)
21252 21252 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21253 21253 ;;
21254 21254 *)
21255 21255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21256 21256 for as_dir in $PATH
21257 21257 do
21258 21258 IFS=$as_save_IFS
21259 21259 test -z "$as_dir" && as_dir=.
21260 21260 for ac_exec_ext in '' $ac_executable_extensions; do
21261 21261 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21262 21262 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21263 21263 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21264 21264 break 2
21265 21265 fi
21266 21266 done
21267 21267 done
21268 21268 IFS=$as_save_IFS
21269 21269
21270 21270 ;;
21271 21271 esac
21272 21272 fi
21273 21273 UNZIP=$ac_cv_path_UNZIP
21274 21274 if test -n "$UNZIP"; then
21275 21275 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21276 21276 $as_echo "$UNZIP" >&6; }
21277 21277 else
21278 21278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21279 21279 $as_echo "no" >&6; }
21280 21280 fi
21281 21281
21282 21282
21283 21283 test -n "$UNZIP" && break
21284 21284 done
21285 21285
21286 21286 else
21287 21287 # If it succeeded, then it was overridden by the user. We will use it
21288 21288 # for the tool.
21289 21289
21290 21290 # First remove it from the list of overridden variables, so we can test
21291 21291 # for unknown variables in the end.
21292 21292 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21293 21293
21294 21294 # Check if we try to supply an empty value
21295 21295 if test "x$UNZIP" = x; then
21296 21296 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
21297 21297 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
21298 21298 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21299 21299 $as_echo_n "checking for UNZIP... " >&6; }
21300 21300 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21301 21301 $as_echo "disabled" >&6; }
21302 21302 else
21303 21303 # Check if the provided tool contains a complete path.
21304 21304 tool_specified="$UNZIP"
21305 21305 tool_basename="${tool_specified##*/}"
21306 21306 if test "x$tool_basename" = "x$tool_specified"; then
21307 21307 # A command without a complete path is provided, search $PATH.
21308 21308 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
21309 21309 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
21310 21310 # Extract the first word of "$tool_basename", so it can be a program name with args.
21311 21311 set dummy $tool_basename; ac_word=$2
21312 21312 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21313 21313 $as_echo_n "checking for $ac_word... " >&6; }
21314 21314 if ${ac_cv_path_UNZIP+:} false; then :
21315 21315 $as_echo_n "(cached) " >&6
21316 21316 else
21317 21317 case $UNZIP in
21318 21318 [\\/]* | ?:[\\/]*)
21319 21319 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21320 21320 ;;
21321 21321 *)
21322 21322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21323 21323 for as_dir in $PATH
21324 21324 do
21325 21325 IFS=$as_save_IFS
21326 21326 test -z "$as_dir" && as_dir=.
21327 21327 for ac_exec_ext in '' $ac_executable_extensions; do
21328 21328 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21329 21329 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21330 21330 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21331 21331 break 2
21332 21332 fi
21333 21333 done
21334 21334 done
21335 21335 IFS=$as_save_IFS
21336 21336
21337 21337 ;;
21338 21338 esac
21339 21339 fi
21340 21340 UNZIP=$ac_cv_path_UNZIP
21341 21341 if test -n "$UNZIP"; then
21342 21342 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21343 21343 $as_echo "$UNZIP" >&6; }
21344 21344 else
21345 21345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21346 21346 $as_echo "no" >&6; }
21347 21347 fi
21348 21348
21349 21349
21350 21350 if test "x$UNZIP" = x; then
21351 21351 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21352 21352 fi
21353 21353 else
21354 21354 # Otherwise we believe it is a complete path. Use it as it is.
21355 21355 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
21356 21356 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
21357 21357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21358 21358 $as_echo_n "checking for UNZIP... " >&6; }
21359 21359 if test ! -x "$tool_specified"; then
21360 21360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21361 21361 $as_echo "not found" >&6; }
21362 21362 as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21363 21363 fi
21364 21364 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21365 21365 $as_echo "$tool_specified" >&6; }
21366 21366 fi
21367 21367 fi
21368 21368 fi
21369 21369
21370 21370 fi
21371 21371
21372 21372
21373 21373
21374 21374 if test "x$UNZIP" = x; then
21375 21375 as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
21376 21376 fi
21377 21377
21378 21378
21379 21379
21380 21380
21381 21381
21382 21382 # Publish this variable in the help.
21383 21383
21384 21384
21385 21385 if [ -z "${ZIP+x}" ]; then
21386 21386 # The variable is not set by user, try to locate tool using the code snippet
21387 21387 for ac_prog in zip
21388 21388 do
21389 21389 # Extract the first word of "$ac_prog", so it can be a program name with args.
21390 21390 set dummy $ac_prog; ac_word=$2
21391 21391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21392 21392 $as_echo_n "checking for $ac_word... " >&6; }
21393 21393 if ${ac_cv_path_ZIP+:} false; then :
21394 21394 $as_echo_n "(cached) " >&6
21395 21395 else
21396 21396 case $ZIP in
21397 21397 [\\/]* | ?:[\\/]*)
21398 21398 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21399 21399 ;;
21400 21400 *)
21401 21401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21402 21402 for as_dir in $PATH
21403 21403 do
21404 21404 IFS=$as_save_IFS
21405 21405 test -z "$as_dir" && as_dir=.
21406 21406 for ac_exec_ext in '' $ac_executable_extensions; do
21407 21407 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21408 21408 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21409 21409 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21410 21410 break 2
21411 21411 fi
21412 21412 done
21413 21413 done
21414 21414 IFS=$as_save_IFS
21415 21415
21416 21416 ;;
21417 21417 esac
21418 21418 fi
21419 21419 ZIP=$ac_cv_path_ZIP
21420 21420 if test -n "$ZIP"; then
21421 21421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21422 21422 $as_echo "$ZIP" >&6; }
21423 21423 else
21424 21424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21425 21425 $as_echo "no" >&6; }
21426 21426 fi
21427 21427
21428 21428
21429 21429 test -n "$ZIP" && break
21430 21430 done
21431 21431
21432 21432 else
21433 21433 # The variable is set, but is it from the command line or the environment?
21434 21434
21435 21435 # Try to remove the string !ZIP! from our list.
21436 21436 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
21437 21437 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21438 21438 # If it failed, the variable was not from the command line. Ignore it,
21439 21439 # but warn the user (except for BASH, which is always set by the calling BASH).
21440 21440 if test "xZIP" != xBASH; then
21441 21441 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
21442 21442 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
21443 21443 fi
21444 21444 # Try to locate tool using the code snippet
21445 21445 for ac_prog in zip
21446 21446 do
21447 21447 # Extract the first word of "$ac_prog", so it can be a program name with args.
21448 21448 set dummy $ac_prog; ac_word=$2
21449 21449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21450 21450 $as_echo_n "checking for $ac_word... " >&6; }
21451 21451 if ${ac_cv_path_ZIP+:} false; then :
21452 21452 $as_echo_n "(cached) " >&6
21453 21453 else
21454 21454 case $ZIP in
21455 21455 [\\/]* | ?:[\\/]*)
21456 21456 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21457 21457 ;;
21458 21458 *)
21459 21459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21460 21460 for as_dir in $PATH
21461 21461 do
21462 21462 IFS=$as_save_IFS
21463 21463 test -z "$as_dir" && as_dir=.
21464 21464 for ac_exec_ext in '' $ac_executable_extensions; do
21465 21465 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21466 21466 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21467 21467 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21468 21468 break 2
21469 21469 fi
21470 21470 done
21471 21471 done
21472 21472 IFS=$as_save_IFS
21473 21473
21474 21474 ;;
21475 21475 esac
21476 21476 fi
21477 21477 ZIP=$ac_cv_path_ZIP
21478 21478 if test -n "$ZIP"; then
21479 21479 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21480 21480 $as_echo "$ZIP" >&6; }
21481 21481 else
21482 21482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21483 21483 $as_echo "no" >&6; }
21484 21484 fi
21485 21485
21486 21486
21487 21487 test -n "$ZIP" && break
21488 21488 done
21489 21489
21490 21490 else
21491 21491 # If it succeeded, then it was overridden by the user. We will use it
21492 21492 # for the tool.
21493 21493
21494 21494 # First remove it from the list of overridden variables, so we can test
21495 21495 # for unknown variables in the end.
21496 21496 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21497 21497
21498 21498 # Check if we try to supply an empty value
21499 21499 if test "x$ZIP" = x; then
21500 21500 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
21501 21501 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
21502 21502 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21503 21503 $as_echo_n "checking for ZIP... " >&6; }
21504 21504 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21505 21505 $as_echo "disabled" >&6; }
21506 21506 else
21507 21507 # Check if the provided tool contains a complete path.
21508 21508 tool_specified="$ZIP"
21509 21509 tool_basename="${tool_specified##*/}"
21510 21510 if test "x$tool_basename" = "x$tool_specified"; then
21511 21511 # A command without a complete path is provided, search $PATH.
21512 21512 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
21513 21513 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
21514 21514 # Extract the first word of "$tool_basename", so it can be a program name with args.
21515 21515 set dummy $tool_basename; ac_word=$2
21516 21516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21517 21517 $as_echo_n "checking for $ac_word... " >&6; }
21518 21518 if ${ac_cv_path_ZIP+:} false; then :
21519 21519 $as_echo_n "(cached) " >&6
21520 21520 else
21521 21521 case $ZIP in
21522 21522 [\\/]* | ?:[\\/]*)
21523 21523 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21524 21524 ;;
21525 21525 *)
21526 21526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21527 21527 for as_dir in $PATH
21528 21528 do
21529 21529 IFS=$as_save_IFS
21530 21530 test -z "$as_dir" && as_dir=.
21531 21531 for ac_exec_ext in '' $ac_executable_extensions; do
21532 21532 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21533 21533 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21534 21534 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21535 21535 break 2
21536 21536 fi
21537 21537 done
21538 21538 done
21539 21539 IFS=$as_save_IFS
21540 21540
21541 21541 ;;
21542 21542 esac
21543 21543 fi
21544 21544 ZIP=$ac_cv_path_ZIP
21545 21545 if test -n "$ZIP"; then
21546 21546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21547 21547 $as_echo "$ZIP" >&6; }
21548 21548 else
21549 21549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21550 21550 $as_echo "no" >&6; }
21551 21551 fi
21552 21552
21553 21553
21554 21554 if test "x$ZIP" = x; then
21555 21555 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21556 21556 fi
21557 21557 else
21558 21558 # Otherwise we believe it is a complete path. Use it as it is.
21559 21559 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
21560 21560 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
21561 21561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21562 21562 $as_echo_n "checking for ZIP... " >&6; }
21563 21563 if test ! -x "$tool_specified"; then
21564 21564 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21565 21565 $as_echo "not found" >&6; }
21566 21566 as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21567 21567 fi
21568 21568 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21569 21569 $as_echo "$tool_specified" >&6; }
21570 21570 fi
21571 21571 fi
21572 21572 fi
21573 21573
21574 21574 fi
21575 21575
21576 21576
21577 21577
21578 21578 if test "x$ZIP" = x; then
21579 21579 as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
21580 21580 fi
21581 21581
21582 21582
21583 21583
21584 21584 # Non-required basic tools
21585 21585
21586 21586
21587 21587
21588 21588 # Publish this variable in the help.
21589 21589
21590 21590
21591 21591 if [ -z "${LDD+x}" ]; then
21592 21592 # The variable is not set by user, try to locate tool using the code snippet
21593 21593 for ac_prog in ldd
21594 21594 do
21595 21595 # Extract the first word of "$ac_prog", so it can be a program name with args.
21596 21596 set dummy $ac_prog; ac_word=$2
21597 21597 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21598 21598 $as_echo_n "checking for $ac_word... " >&6; }
21599 21599 if ${ac_cv_path_LDD+:} false; then :
21600 21600 $as_echo_n "(cached) " >&6
21601 21601 else
21602 21602 case $LDD in
21603 21603 [\\/]* | ?:[\\/]*)
21604 21604 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21605 21605 ;;
21606 21606 *)
21607 21607 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21608 21608 for as_dir in $PATH
21609 21609 do
21610 21610 IFS=$as_save_IFS
21611 21611 test -z "$as_dir" && as_dir=.
21612 21612 for ac_exec_ext in '' $ac_executable_extensions; do
21613 21613 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21614 21614 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21615 21615 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21616 21616 break 2
21617 21617 fi
21618 21618 done
21619 21619 done
21620 21620 IFS=$as_save_IFS
21621 21621
21622 21622 ;;
21623 21623 esac
21624 21624 fi
21625 21625 LDD=$ac_cv_path_LDD
21626 21626 if test -n "$LDD"; then
21627 21627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21628 21628 $as_echo "$LDD" >&6; }
21629 21629 else
21630 21630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21631 21631 $as_echo "no" >&6; }
21632 21632 fi
21633 21633
21634 21634
21635 21635 test -n "$LDD" && break
21636 21636 done
21637 21637
21638 21638 else
21639 21639 # The variable is set, but is it from the command line or the environment?
21640 21640
21641 21641 # Try to remove the string !LDD! from our list.
21642 21642 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
21643 21643 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21644 21644 # If it failed, the variable was not from the command line. Ignore it,
21645 21645 # but warn the user (except for BASH, which is always set by the calling BASH).
21646 21646 if test "xLDD" != xBASH; then
21647 21647 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
21648 21648 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
21649 21649 fi
21650 21650 # Try to locate tool using the code snippet
21651 21651 for ac_prog in ldd
21652 21652 do
21653 21653 # Extract the first word of "$ac_prog", so it can be a program name with args.
21654 21654 set dummy $ac_prog; ac_word=$2
21655 21655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21656 21656 $as_echo_n "checking for $ac_word... " >&6; }
21657 21657 if ${ac_cv_path_LDD+:} false; then :
21658 21658 $as_echo_n "(cached) " >&6
21659 21659 else
21660 21660 case $LDD in
21661 21661 [\\/]* | ?:[\\/]*)
21662 21662 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21663 21663 ;;
21664 21664 *)
21665 21665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21666 21666 for as_dir in $PATH
21667 21667 do
21668 21668 IFS=$as_save_IFS
21669 21669 test -z "$as_dir" && as_dir=.
21670 21670 for ac_exec_ext in '' $ac_executable_extensions; do
21671 21671 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21672 21672 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21673 21673 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21674 21674 break 2
21675 21675 fi
21676 21676 done
21677 21677 done
21678 21678 IFS=$as_save_IFS
21679 21679
21680 21680 ;;
21681 21681 esac
21682 21682 fi
21683 21683 LDD=$ac_cv_path_LDD
21684 21684 if test -n "$LDD"; then
21685 21685 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21686 21686 $as_echo "$LDD" >&6; }
21687 21687 else
21688 21688 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21689 21689 $as_echo "no" >&6; }
21690 21690 fi
21691 21691
21692 21692
21693 21693 test -n "$LDD" && break
21694 21694 done
21695 21695
21696 21696 else
21697 21697 # If it succeeded, then it was overridden by the user. We will use it
21698 21698 # for the tool.
21699 21699
21700 21700 # First remove it from the list of overridden variables, so we can test
21701 21701 # for unknown variables in the end.
21702 21702 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21703 21703
21704 21704 # Check if we try to supply an empty value
21705 21705 if test "x$LDD" = x; then
21706 21706 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
21707 21707 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
21708 21708 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21709 21709 $as_echo_n "checking for LDD... " >&6; }
21710 21710 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21711 21711 $as_echo "disabled" >&6; }
21712 21712 else
21713 21713 # Check if the provided tool contains a complete path.
21714 21714 tool_specified="$LDD"
21715 21715 tool_basename="${tool_specified##*/}"
21716 21716 if test "x$tool_basename" = "x$tool_specified"; then
21717 21717 # A command without a complete path is provided, search $PATH.
21718 21718 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
21719 21719 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
21720 21720 # Extract the first word of "$tool_basename", so it can be a program name with args.
21721 21721 set dummy $tool_basename; ac_word=$2
21722 21722 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21723 21723 $as_echo_n "checking for $ac_word... " >&6; }
21724 21724 if ${ac_cv_path_LDD+:} false; then :
21725 21725 $as_echo_n "(cached) " >&6
21726 21726 else
21727 21727 case $LDD in
21728 21728 [\\/]* | ?:[\\/]*)
21729 21729 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21730 21730 ;;
21731 21731 *)
21732 21732 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21733 21733 for as_dir in $PATH
21734 21734 do
21735 21735 IFS=$as_save_IFS
21736 21736 test -z "$as_dir" && as_dir=.
21737 21737 for ac_exec_ext in '' $ac_executable_extensions; do
21738 21738 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21739 21739 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21740 21740 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21741 21741 break 2
21742 21742 fi
21743 21743 done
21744 21744 done
21745 21745 IFS=$as_save_IFS
21746 21746
21747 21747 ;;
21748 21748 esac
21749 21749 fi
21750 21750 LDD=$ac_cv_path_LDD
21751 21751 if test -n "$LDD"; then
21752 21752 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21753 21753 $as_echo "$LDD" >&6; }
21754 21754 else
21755 21755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21756 21756 $as_echo "no" >&6; }
21757 21757 fi
21758 21758
21759 21759
21760 21760 if test "x$LDD" = x; then
21761 21761 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21762 21762 fi
21763 21763 else
21764 21764 # Otherwise we believe it is a complete path. Use it as it is.
21765 21765 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
21766 21766 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
21767 21767 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21768 21768 $as_echo_n "checking for LDD... " >&6; }
21769 21769 if test ! -x "$tool_specified"; then
21770 21770 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21771 21771 $as_echo "not found" >&6; }
21772 21772 as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
21773 21773 fi
21774 21774 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21775 21775 $as_echo "$tool_specified" >&6; }
21776 21776 fi
21777 21777 fi
21778 21778 fi
21779 21779
21780 21780 fi
21781 21781
21782 21782
21783 21783 if test "x$LDD" = "x"; then
21784 21784 # List shared lib dependencies is used for
21785 21785 # debug output and checking for forbidden dependencies.
21786 21786 # We can build without it.
21787 21787 LDD="true"
21788 21788 fi
21789 21789
21790 21790
21791 21791 # Publish this variable in the help.
21792 21792
21793 21793
21794 21794 if [ -z "${OTOOL+x}" ]; then
21795 21795 # The variable is not set by user, try to locate tool using the code snippet
21796 21796 for ac_prog in otool
21797 21797 do
21798 21798 # Extract the first word of "$ac_prog", so it can be a program name with args.
21799 21799 set dummy $ac_prog; ac_word=$2
21800 21800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21801 21801 $as_echo_n "checking for $ac_word... " >&6; }
21802 21802 if ${ac_cv_path_OTOOL+:} false; then :
21803 21803 $as_echo_n "(cached) " >&6
21804 21804 else
21805 21805 case $OTOOL in
21806 21806 [\\/]* | ?:[\\/]*)
21807 21807 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21808 21808 ;;
21809 21809 *)
21810 21810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21811 21811 for as_dir in $PATH
21812 21812 do
21813 21813 IFS=$as_save_IFS
21814 21814 test -z "$as_dir" && as_dir=.
21815 21815 for ac_exec_ext in '' $ac_executable_extensions; do
21816 21816 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21817 21817 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21818 21818 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21819 21819 break 2
21820 21820 fi
21821 21821 done
21822 21822 done
21823 21823 IFS=$as_save_IFS
21824 21824
21825 21825 ;;
21826 21826 esac
21827 21827 fi
21828 21828 OTOOL=$ac_cv_path_OTOOL
21829 21829 if test -n "$OTOOL"; then
21830 21830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21831 21831 $as_echo "$OTOOL" >&6; }
21832 21832 else
21833 21833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21834 21834 $as_echo "no" >&6; }
21835 21835 fi
21836 21836
21837 21837
21838 21838 test -n "$OTOOL" && break
21839 21839 done
21840 21840
21841 21841 else
21842 21842 # The variable is set, but is it from the command line or the environment?
21843 21843
21844 21844 # Try to remove the string !OTOOL! from our list.
21845 21845 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
21846 21846 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21847 21847 # If it failed, the variable was not from the command line. Ignore it,
21848 21848 # but warn the user (except for BASH, which is always set by the calling BASH).
21849 21849 if test "xOTOOL" != xBASH; then
21850 21850 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
21851 21851 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
21852 21852 fi
21853 21853 # Try to locate tool using the code snippet
21854 21854 for ac_prog in otool
21855 21855 do
21856 21856 # Extract the first word of "$ac_prog", so it can be a program name with args.
21857 21857 set dummy $ac_prog; ac_word=$2
21858 21858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21859 21859 $as_echo_n "checking for $ac_word... " >&6; }
21860 21860 if ${ac_cv_path_OTOOL+:} false; then :
21861 21861 $as_echo_n "(cached) " >&6
21862 21862 else
21863 21863 case $OTOOL in
21864 21864 [\\/]* | ?:[\\/]*)
21865 21865 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21866 21866 ;;
21867 21867 *)
21868 21868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21869 21869 for as_dir in $PATH
21870 21870 do
21871 21871 IFS=$as_save_IFS
21872 21872 test -z "$as_dir" && as_dir=.
21873 21873 for ac_exec_ext in '' $ac_executable_extensions; do
21874 21874 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21875 21875 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21876 21876 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21877 21877 break 2
21878 21878 fi
21879 21879 done
21880 21880 done
21881 21881 IFS=$as_save_IFS
21882 21882
21883 21883 ;;
21884 21884 esac
21885 21885 fi
21886 21886 OTOOL=$ac_cv_path_OTOOL
21887 21887 if test -n "$OTOOL"; then
21888 21888 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21889 21889 $as_echo "$OTOOL" >&6; }
21890 21890 else
21891 21891 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21892 21892 $as_echo "no" >&6; }
21893 21893 fi
21894 21894
21895 21895
21896 21896 test -n "$OTOOL" && break
21897 21897 done
21898 21898
21899 21899 else
21900 21900 # If it succeeded, then it was overridden by the user. We will use it
21901 21901 # for the tool.
21902 21902
21903 21903 # First remove it from the list of overridden variables, so we can test
21904 21904 # for unknown variables in the end.
21905 21905 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21906 21906
21907 21907 # Check if we try to supply an empty value
21908 21908 if test "x$OTOOL" = x; then
21909 21909 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
21910 21910 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
21911 21911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21912 21912 $as_echo_n "checking for OTOOL... " >&6; }
21913 21913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21914 21914 $as_echo "disabled" >&6; }
21915 21915 else
21916 21916 # Check if the provided tool contains a complete path.
21917 21917 tool_specified="$OTOOL"
21918 21918 tool_basename="${tool_specified##*/}"
21919 21919 if test "x$tool_basename" = "x$tool_specified"; then
21920 21920 # A command without a complete path is provided, search $PATH.
21921 21921 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21922 21922 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21923 21923 # Extract the first word of "$tool_basename", so it can be a program name with args.
21924 21924 set dummy $tool_basename; ac_word=$2
21925 21925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21926 21926 $as_echo_n "checking for $ac_word... " >&6; }
21927 21927 if ${ac_cv_path_OTOOL+:} false; then :
21928 21928 $as_echo_n "(cached) " >&6
21929 21929 else
21930 21930 case $OTOOL in
21931 21931 [\\/]* | ?:[\\/]*)
21932 21932 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21933 21933 ;;
21934 21934 *)
21935 21935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21936 21936 for as_dir in $PATH
21937 21937 do
21938 21938 IFS=$as_save_IFS
21939 21939 test -z "$as_dir" && as_dir=.
21940 21940 for ac_exec_ext in '' $ac_executable_extensions; do
21941 21941 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21942 21942 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21943 21943 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21944 21944 break 2
21945 21945 fi
21946 21946 done
21947 21947 done
21948 21948 IFS=$as_save_IFS
21949 21949
21950 21950 ;;
21951 21951 esac
21952 21952 fi
21953 21953 OTOOL=$ac_cv_path_OTOOL
21954 21954 if test -n "$OTOOL"; then
21955 21955 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21956 21956 $as_echo "$OTOOL" >&6; }
21957 21957 else
21958 21958 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21959 21959 $as_echo "no" >&6; }
21960 21960 fi
21961 21961
21962 21962
21963 21963 if test "x$OTOOL" = x; then
21964 21964 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21965 21965 fi
21966 21966 else
21967 21967 # Otherwise we believe it is a complete path. Use it as it is.
21968 21968 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21969 21969 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21970 21970 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21971 21971 $as_echo_n "checking for OTOOL... " >&6; }
21972 21972 if test ! -x "$tool_specified"; then
21973 21973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21974 21974 $as_echo "not found" >&6; }
21975 21975 as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21976 21976 fi
21977 21977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21978 21978 $as_echo "$tool_specified" >&6; }
21979 21979 fi
21980 21980 fi
21981 21981 fi
21982 21982
21983 21983 fi
21984 21984
21985 21985
21986 21986 if test "x$OTOOL" = "x"; then
21987 21987 OTOOL="true"
21988 21988 fi
21989 21989
21990 21990
21991 21991 # Publish this variable in the help.
21992 21992
21993 21993
21994 21994 if [ -z "${READELF+x}" ]; then
21995 21995 # The variable is not set by user, try to locate tool using the code snippet
21996 21996 for ac_prog in greadelf readelf
21997 21997 do
21998 21998 # Extract the first word of "$ac_prog", so it can be a program name with args.
21999 21999 set dummy $ac_prog; ac_word=$2
22000 22000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22001 22001 $as_echo_n "checking for $ac_word... " >&6; }
22002 22002 if ${ac_cv_path_READELF+:} false; then :
22003 22003 $as_echo_n "(cached) " >&6
22004 22004 else
22005 22005 case $READELF in
22006 22006 [\\/]* | ?:[\\/]*)
22007 22007 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22008 22008 ;;
22009 22009 *)
22010 22010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22011 22011 for as_dir in $PATH
22012 22012 do
22013 22013 IFS=$as_save_IFS
22014 22014 test -z "$as_dir" && as_dir=.
22015 22015 for ac_exec_ext in '' $ac_executable_extensions; do
22016 22016 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22017 22017 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22018 22018 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22019 22019 break 2
22020 22020 fi
22021 22021 done
22022 22022 done
22023 22023 IFS=$as_save_IFS
22024 22024
22025 22025 ;;
22026 22026 esac
22027 22027 fi
22028 22028 READELF=$ac_cv_path_READELF
22029 22029 if test -n "$READELF"; then
22030 22030 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22031 22031 $as_echo "$READELF" >&6; }
22032 22032 else
22033 22033 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22034 22034 $as_echo "no" >&6; }
22035 22035 fi
22036 22036
22037 22037
22038 22038 test -n "$READELF" && break
22039 22039 done
22040 22040
22041 22041 else
22042 22042 # The variable is set, but is it from the command line or the environment?
22043 22043
22044 22044 # Try to remove the string !READELF! from our list.
22045 22045 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
22046 22046 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22047 22047 # If it failed, the variable was not from the command line. Ignore it,
22048 22048 # but warn the user (except for BASH, which is always set by the calling BASH).
22049 22049 if test "xREADELF" != xBASH; then
22050 22050 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
22051 22051 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
22052 22052 fi
22053 22053 # Try to locate tool using the code snippet
22054 22054 for ac_prog in greadelf readelf
22055 22055 do
22056 22056 # Extract the first word of "$ac_prog", so it can be a program name with args.
22057 22057 set dummy $ac_prog; ac_word=$2
22058 22058 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22059 22059 $as_echo_n "checking for $ac_word... " >&6; }
22060 22060 if ${ac_cv_path_READELF+:} false; then :
22061 22061 $as_echo_n "(cached) " >&6
22062 22062 else
22063 22063 case $READELF in
22064 22064 [\\/]* | ?:[\\/]*)
22065 22065 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22066 22066 ;;
22067 22067 *)
22068 22068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22069 22069 for as_dir in $PATH
22070 22070 do
22071 22071 IFS=$as_save_IFS
22072 22072 test -z "$as_dir" && as_dir=.
22073 22073 for ac_exec_ext in '' $ac_executable_extensions; do
22074 22074 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22075 22075 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22076 22076 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22077 22077 break 2
22078 22078 fi
22079 22079 done
22080 22080 done
22081 22081 IFS=$as_save_IFS
22082 22082
22083 22083 ;;
22084 22084 esac
22085 22085 fi
22086 22086 READELF=$ac_cv_path_READELF
22087 22087 if test -n "$READELF"; then
22088 22088 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22089 22089 $as_echo "$READELF" >&6; }
22090 22090 else
22091 22091 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22092 22092 $as_echo "no" >&6; }
22093 22093 fi
22094 22094
22095 22095
22096 22096 test -n "$READELF" && break
22097 22097 done
22098 22098
22099 22099 else
22100 22100 # If it succeeded, then it was overridden by the user. We will use it
22101 22101 # for the tool.
22102 22102
22103 22103 # First remove it from the list of overridden variables, so we can test
22104 22104 # for unknown variables in the end.
22105 22105 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22106 22106
22107 22107 # Check if we try to supply an empty value
22108 22108 if test "x$READELF" = x; then
22109 22109 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
22110 22110 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
22111 22111 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22112 22112 $as_echo_n "checking for READELF... " >&6; }
22113 22113 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22114 22114 $as_echo "disabled" >&6; }
22115 22115 else
22116 22116 # Check if the provided tool contains a complete path.
22117 22117 tool_specified="$READELF"
22118 22118 tool_basename="${tool_specified##*/}"
22119 22119 if test "x$tool_basename" = "x$tool_specified"; then
22120 22120 # A command without a complete path is provided, search $PATH.
22121 22121 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
22122 22122 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
22123 22123 # Extract the first word of "$tool_basename", so it can be a program name with args.
22124 22124 set dummy $tool_basename; ac_word=$2
22125 22125 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22126 22126 $as_echo_n "checking for $ac_word... " >&6; }
22127 22127 if ${ac_cv_path_READELF+:} false; then :
22128 22128 $as_echo_n "(cached) " >&6
22129 22129 else
22130 22130 case $READELF in
22131 22131 [\\/]* | ?:[\\/]*)
22132 22132 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22133 22133 ;;
22134 22134 *)
22135 22135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22136 22136 for as_dir in $PATH
22137 22137 do
22138 22138 IFS=$as_save_IFS
22139 22139 test -z "$as_dir" && as_dir=.
22140 22140 for ac_exec_ext in '' $ac_executable_extensions; do
22141 22141 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22142 22142 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22143 22143 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22144 22144 break 2
22145 22145 fi
22146 22146 done
22147 22147 done
22148 22148 IFS=$as_save_IFS
22149 22149
22150 22150 ;;
22151 22151 esac
22152 22152 fi
22153 22153 READELF=$ac_cv_path_READELF
22154 22154 if test -n "$READELF"; then
22155 22155 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22156 22156 $as_echo "$READELF" >&6; }
22157 22157 else
22158 22158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22159 22159 $as_echo "no" >&6; }
22160 22160 fi
22161 22161
22162 22162
22163 22163 if test "x$READELF" = x; then
22164 22164 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22165 22165 fi
22166 22166 else
22167 22167 # Otherwise we believe it is a complete path. Use it as it is.
22168 22168 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
22169 22169 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
22170 22170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22171 22171 $as_echo_n "checking for READELF... " >&6; }
22172 22172 if test ! -x "$tool_specified"; then
22173 22173 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22174 22174 $as_echo "not found" >&6; }
22175 22175 as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
22176 22176 fi
22177 22177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22178 22178 $as_echo "$tool_specified" >&6; }
22179 22179 fi
22180 22180 fi
22181 22181 fi
22182 22182
22183 22183 fi
22184 22184
22185 22185
22186 22186
22187 22187
22188 22188 # Publish this variable in the help.
22189 22189
22190 22190
22191 22191 if [ -z "${HG+x}" ]; then
22192 22192 # The variable is not set by user, try to locate tool using the code snippet
22193 22193 for ac_prog in hg
22194 22194 do
22195 22195 # Extract the first word of "$ac_prog", so it can be a program name with args.
22196 22196 set dummy $ac_prog; ac_word=$2
22197 22197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22198 22198 $as_echo_n "checking for $ac_word... " >&6; }
22199 22199 if ${ac_cv_path_HG+:} false; then :
22200 22200 $as_echo_n "(cached) " >&6
22201 22201 else
22202 22202 case $HG in
22203 22203 [\\/]* | ?:[\\/]*)
22204 22204 ac_cv_path_HG="$HG" # Let the user override the test with a path.
22205 22205 ;;
22206 22206 *)
22207 22207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22208 22208 for as_dir in $PATH
22209 22209 do
22210 22210 IFS=$as_save_IFS
22211 22211 test -z "$as_dir" && as_dir=.
22212 22212 for ac_exec_ext in '' $ac_executable_extensions; do
22213 22213 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22214 22214 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22215 22215 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22216 22216 break 2
22217 22217 fi
22218 22218 done
22219 22219 done
22220 22220 IFS=$as_save_IFS
22221 22221
22222 22222 ;;
22223 22223 esac
22224 22224 fi
22225 22225 HG=$ac_cv_path_HG
22226 22226 if test -n "$HG"; then
22227 22227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22228 22228 $as_echo "$HG" >&6; }
22229 22229 else
22230 22230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22231 22231 $as_echo "no" >&6; }
22232 22232 fi
22233 22233
22234 22234
22235 22235 test -n "$HG" && break
22236 22236 done
22237 22237
22238 22238 else
22239 22239 # The variable is set, but is it from the command line or the environment?
22240 22240
22241 22241 # Try to remove the string !HG! from our list.
22242 22242 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
22243 22243 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22244 22244 # If it failed, the variable was not from the command line. Ignore it,
22245 22245 # but warn the user (except for BASH, which is always set by the calling BASH).
22246 22246 if test "xHG" != xBASH; then
22247 22247 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
22248 22248 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
22249 22249 fi
22250 22250 # Try to locate tool using the code snippet
22251 22251 for ac_prog in hg
22252 22252 do
22253 22253 # Extract the first word of "$ac_prog", so it can be a program name with args.
22254 22254 set dummy $ac_prog; ac_word=$2
22255 22255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22256 22256 $as_echo_n "checking for $ac_word... " >&6; }
22257 22257 if ${ac_cv_path_HG+:} false; then :
22258 22258 $as_echo_n "(cached) " >&6
22259 22259 else
22260 22260 case $HG in
22261 22261 [\\/]* | ?:[\\/]*)
22262 22262 ac_cv_path_HG="$HG" # Let the user override the test with a path.
22263 22263 ;;
22264 22264 *)
22265 22265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22266 22266 for as_dir in $PATH
22267 22267 do
22268 22268 IFS=$as_save_IFS
22269 22269 test -z "$as_dir" && as_dir=.
22270 22270 for ac_exec_ext in '' $ac_executable_extensions; do
22271 22271 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22272 22272 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22273 22273 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22274 22274 break 2
22275 22275 fi
22276 22276 done
22277 22277 done
22278 22278 IFS=$as_save_IFS
22279 22279
22280 22280 ;;
22281 22281 esac
22282 22282 fi
22283 22283 HG=$ac_cv_path_HG
22284 22284 if test -n "$HG"; then
22285 22285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22286 22286 $as_echo "$HG" >&6; }
22287 22287 else
22288 22288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22289 22289 $as_echo "no" >&6; }
22290 22290 fi
22291 22291
22292 22292
22293 22293 test -n "$HG" && break
22294 22294 done
22295 22295
22296 22296 else
22297 22297 # If it succeeded, then it was overridden by the user. We will use it
22298 22298 # for the tool.
22299 22299
22300 22300 # First remove it from the list of overridden variables, so we can test
22301 22301 # for unknown variables in the end.
22302 22302 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22303 22303
22304 22304 # Check if we try to supply an empty value
22305 22305 if test "x$HG" = x; then
22306 22306 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
22307 22307 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
22308 22308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22309 22309 $as_echo_n "checking for HG... " >&6; }
22310 22310 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22311 22311 $as_echo "disabled" >&6; }
22312 22312 else
22313 22313 # Check if the provided tool contains a complete path.
22314 22314 tool_specified="$HG"
22315 22315 tool_basename="${tool_specified##*/}"
22316 22316 if test "x$tool_basename" = "x$tool_specified"; then
22317 22317 # A command without a complete path is provided, search $PATH.
22318 22318 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
22319 22319 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
22320 22320 # Extract the first word of "$tool_basename", so it can be a program name with args.
22321 22321 set dummy $tool_basename; ac_word=$2
22322 22322 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22323 22323 $as_echo_n "checking for $ac_word... " >&6; }
22324 22324 if ${ac_cv_path_HG+:} false; then :
22325 22325 $as_echo_n "(cached) " >&6
22326 22326 else
22327 22327 case $HG in
22328 22328 [\\/]* | ?:[\\/]*)
22329 22329 ac_cv_path_HG="$HG" # Let the user override the test with a path.
22330 22330 ;;
22331 22331 *)
22332 22332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22333 22333 for as_dir in $PATH
22334 22334 do
22335 22335 IFS=$as_save_IFS
22336 22336 test -z "$as_dir" && as_dir=.
22337 22337 for ac_exec_ext in '' $ac_executable_extensions; do
22338 22338 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22339 22339 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22340 22340 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22341 22341 break 2
22342 22342 fi
22343 22343 done
22344 22344 done
22345 22345 IFS=$as_save_IFS
22346 22346
22347 22347 ;;
22348 22348 esac
22349 22349 fi
22350 22350 HG=$ac_cv_path_HG
22351 22351 if test -n "$HG"; then
22352 22352 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22353 22353 $as_echo "$HG" >&6; }
22354 22354 else
22355 22355 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22356 22356 $as_echo "no" >&6; }
22357 22357 fi
22358 22358
22359 22359
22360 22360 if test "x$HG" = x; then
22361 22361 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22362 22362 fi
22363 22363 else
22364 22364 # Otherwise we believe it is a complete path. Use it as it is.
22365 22365 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
22366 22366 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
22367 22367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22368 22368 $as_echo_n "checking for HG... " >&6; }
22369 22369 if test ! -x "$tool_specified"; then
22370 22370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22371 22371 $as_echo "not found" >&6; }
22372 22372 as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
22373 22373 fi
22374 22374 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22375 22375 $as_echo "$tool_specified" >&6; }
22376 22376 fi
22377 22377 fi
22378 22378 fi
22379 22379
22380 22380 fi
22381 22381
22382 22382
22383 22383
22384 22384
22385 22385 # Publish this variable in the help.
22386 22386
22387 22387
22388 22388 if [ -z "${STAT+x}" ]; then
22389 22389 # The variable is not set by user, try to locate tool using the code snippet
22390 22390 for ac_prog in stat
22391 22391 do
22392 22392 # Extract the first word of "$ac_prog", so it can be a program name with args.
22393 22393 set dummy $ac_prog; ac_word=$2
22394 22394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22395 22395 $as_echo_n "checking for $ac_word... " >&6; }
22396 22396 if ${ac_cv_path_STAT+:} false; then :
22397 22397 $as_echo_n "(cached) " >&6
22398 22398 else
22399 22399 case $STAT in
22400 22400 [\\/]* | ?:[\\/]*)
22401 22401 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22402 22402 ;;
22403 22403 *)
22404 22404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22405 22405 for as_dir in $PATH
22406 22406 do
22407 22407 IFS=$as_save_IFS
22408 22408 test -z "$as_dir" && as_dir=.
22409 22409 for ac_exec_ext in '' $ac_executable_extensions; do
22410 22410 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22411 22411 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22412 22412 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22413 22413 break 2
22414 22414 fi
22415 22415 done
22416 22416 done
22417 22417 IFS=$as_save_IFS
22418 22418
22419 22419 ;;
22420 22420 esac
22421 22421 fi
22422 22422 STAT=$ac_cv_path_STAT
22423 22423 if test -n "$STAT"; then
22424 22424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22425 22425 $as_echo "$STAT" >&6; }
22426 22426 else
22427 22427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22428 22428 $as_echo "no" >&6; }
22429 22429 fi
22430 22430
22431 22431
22432 22432 test -n "$STAT" && break
22433 22433 done
22434 22434
22435 22435 else
22436 22436 # The variable is set, but is it from the command line or the environment?
22437 22437
22438 22438 # Try to remove the string !STAT! from our list.
22439 22439 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
22440 22440 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22441 22441 # If it failed, the variable was not from the command line. Ignore it,
22442 22442 # but warn the user (except for BASH, which is always set by the calling BASH).
22443 22443 if test "xSTAT" != xBASH; then
22444 22444 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
22445 22445 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
22446 22446 fi
22447 22447 # Try to locate tool using the code snippet
22448 22448 for ac_prog in stat
22449 22449 do
22450 22450 # Extract the first word of "$ac_prog", so it can be a program name with args.
22451 22451 set dummy $ac_prog; ac_word=$2
22452 22452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22453 22453 $as_echo_n "checking for $ac_word... " >&6; }
22454 22454 if ${ac_cv_path_STAT+:} false; then :
22455 22455 $as_echo_n "(cached) " >&6
22456 22456 else
22457 22457 case $STAT in
22458 22458 [\\/]* | ?:[\\/]*)
22459 22459 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22460 22460 ;;
22461 22461 *)
22462 22462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22463 22463 for as_dir in $PATH
22464 22464 do
22465 22465 IFS=$as_save_IFS
22466 22466 test -z "$as_dir" && as_dir=.
22467 22467 for ac_exec_ext in '' $ac_executable_extensions; do
22468 22468 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22469 22469 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22470 22470 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22471 22471 break 2
22472 22472 fi
22473 22473 done
22474 22474 done
22475 22475 IFS=$as_save_IFS
22476 22476
22477 22477 ;;
22478 22478 esac
22479 22479 fi
22480 22480 STAT=$ac_cv_path_STAT
22481 22481 if test -n "$STAT"; then
22482 22482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22483 22483 $as_echo "$STAT" >&6; }
22484 22484 else
22485 22485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22486 22486 $as_echo "no" >&6; }
22487 22487 fi
22488 22488
22489 22489
22490 22490 test -n "$STAT" && break
22491 22491 done
22492 22492
22493 22493 else
22494 22494 # If it succeeded, then it was overridden by the user. We will use it
22495 22495 # for the tool.
22496 22496
22497 22497 # First remove it from the list of overridden variables, so we can test
22498 22498 # for unknown variables in the end.
22499 22499 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22500 22500
22501 22501 # Check if we try to supply an empty value
22502 22502 if test "x$STAT" = x; then
22503 22503 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
22504 22504 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
22505 22505 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22506 22506 $as_echo_n "checking for STAT... " >&6; }
22507 22507 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22508 22508 $as_echo "disabled" >&6; }
22509 22509 else
22510 22510 # Check if the provided tool contains a complete path.
22511 22511 tool_specified="$STAT"
22512 22512 tool_basename="${tool_specified##*/}"
22513 22513 if test "x$tool_basename" = "x$tool_specified"; then
22514 22514 # A command without a complete path is provided, search $PATH.
22515 22515 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
22516 22516 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
22517 22517 # Extract the first word of "$tool_basename", so it can be a program name with args.
22518 22518 set dummy $tool_basename; ac_word=$2
22519 22519 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22520 22520 $as_echo_n "checking for $ac_word... " >&6; }
22521 22521 if ${ac_cv_path_STAT+:} false; then :
22522 22522 $as_echo_n "(cached) " >&6
22523 22523 else
22524 22524 case $STAT in
22525 22525 [\\/]* | ?:[\\/]*)
22526 22526 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22527 22527 ;;
22528 22528 *)
22529 22529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22530 22530 for as_dir in $PATH
22531 22531 do
22532 22532 IFS=$as_save_IFS
22533 22533 test -z "$as_dir" && as_dir=.
22534 22534 for ac_exec_ext in '' $ac_executable_extensions; do
22535 22535 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22536 22536 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22537 22537 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22538 22538 break 2
22539 22539 fi
22540 22540 done
22541 22541 done
22542 22542 IFS=$as_save_IFS
22543 22543
22544 22544 ;;
22545 22545 esac
22546 22546 fi
22547 22547 STAT=$ac_cv_path_STAT
22548 22548 if test -n "$STAT"; then
22549 22549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22550 22550 $as_echo "$STAT" >&6; }
22551 22551 else
22552 22552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22553 22553 $as_echo "no" >&6; }
22554 22554 fi
22555 22555
22556 22556
22557 22557 if test "x$STAT" = x; then
22558 22558 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22559 22559 fi
22560 22560 else
22561 22561 # Otherwise we believe it is a complete path. Use it as it is.
22562 22562 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
22563 22563 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
22564 22564 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22565 22565 $as_echo_n "checking for STAT... " >&6; }
22566 22566 if test ! -x "$tool_specified"; then
22567 22567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22568 22568 $as_echo "not found" >&6; }
22569 22569 as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
22570 22570 fi
22571 22571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22572 22572 $as_echo "$tool_specified" >&6; }
22573 22573 fi
22574 22574 fi
22575 22575 fi
22576 22576
22577 22577 fi
22578 22578
22579 22579
22580 22580
22581 22581
22582 22582 # Publish this variable in the help.
22583 22583
22584 22584
22585 22585 if [ -z "${TIME+x}" ]; then
22586 22586 # The variable is not set by user, try to locate tool using the code snippet
22587 22587 for ac_prog in time
22588 22588 do
22589 22589 # Extract the first word of "$ac_prog", so it can be a program name with args.
22590 22590 set dummy $ac_prog; ac_word=$2
22591 22591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22592 22592 $as_echo_n "checking for $ac_word... " >&6; }
22593 22593 if ${ac_cv_path_TIME+:} false; then :
22594 22594 $as_echo_n "(cached) " >&6
22595 22595 else
22596 22596 case $TIME in
22597 22597 [\\/]* | ?:[\\/]*)
22598 22598 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22599 22599 ;;
22600 22600 *)
22601 22601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22602 22602 for as_dir in $PATH
22603 22603 do
22604 22604 IFS=$as_save_IFS
22605 22605 test -z "$as_dir" && as_dir=.
22606 22606 for ac_exec_ext in '' $ac_executable_extensions; do
22607 22607 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22608 22608 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22609 22609 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22610 22610 break 2
22611 22611 fi
22612 22612 done
22613 22613 done
22614 22614 IFS=$as_save_IFS
22615 22615
22616 22616 ;;
22617 22617 esac
22618 22618 fi
22619 22619 TIME=$ac_cv_path_TIME
22620 22620 if test -n "$TIME"; then
22621 22621 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22622 22622 $as_echo "$TIME" >&6; }
22623 22623 else
22624 22624 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22625 22625 $as_echo "no" >&6; }
22626 22626 fi
22627 22627
22628 22628
22629 22629 test -n "$TIME" && break
22630 22630 done
22631 22631
22632 22632 else
22633 22633 # The variable is set, but is it from the command line or the environment?
22634 22634
22635 22635 # Try to remove the string !TIME! from our list.
22636 22636 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
22637 22637 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22638 22638 # If it failed, the variable was not from the command line. Ignore it,
22639 22639 # but warn the user (except for BASH, which is always set by the calling BASH).
22640 22640 if test "xTIME" != xBASH; then
22641 22641 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
22642 22642 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
22643 22643 fi
22644 22644 # Try to locate tool using the code snippet
22645 22645 for ac_prog in time
22646 22646 do
22647 22647 # Extract the first word of "$ac_prog", so it can be a program name with args.
22648 22648 set dummy $ac_prog; ac_word=$2
22649 22649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22650 22650 $as_echo_n "checking for $ac_word... " >&6; }
22651 22651 if ${ac_cv_path_TIME+:} false; then :
22652 22652 $as_echo_n "(cached) " >&6
22653 22653 else
22654 22654 case $TIME in
22655 22655 [\\/]* | ?:[\\/]*)
22656 22656 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22657 22657 ;;
22658 22658 *)
22659 22659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22660 22660 for as_dir in $PATH
22661 22661 do
22662 22662 IFS=$as_save_IFS
22663 22663 test -z "$as_dir" && as_dir=.
22664 22664 for ac_exec_ext in '' $ac_executable_extensions; do
22665 22665 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22666 22666 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22667 22667 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22668 22668 break 2
22669 22669 fi
22670 22670 done
22671 22671 done
22672 22672 IFS=$as_save_IFS
22673 22673
22674 22674 ;;
22675 22675 esac
22676 22676 fi
22677 22677 TIME=$ac_cv_path_TIME
22678 22678 if test -n "$TIME"; then
22679 22679 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22680 22680 $as_echo "$TIME" >&6; }
22681 22681 else
22682 22682 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22683 22683 $as_echo "no" >&6; }
22684 22684 fi
22685 22685
22686 22686
22687 22687 test -n "$TIME" && break
22688 22688 done
22689 22689
22690 22690 else
22691 22691 # If it succeeded, then it was overridden by the user. We will use it
22692 22692 # for the tool.
22693 22693
22694 22694 # First remove it from the list of overridden variables, so we can test
22695 22695 # for unknown variables in the end.
22696 22696 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22697 22697
22698 22698 # Check if we try to supply an empty value
22699 22699 if test "x$TIME" = x; then
22700 22700 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
22701 22701 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
22702 22702 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22703 22703 $as_echo_n "checking for TIME... " >&6; }
22704 22704 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22705 22705 $as_echo "disabled" >&6; }
22706 22706 else
22707 22707 # Check if the provided tool contains a complete path.
22708 22708 tool_specified="$TIME"
22709 22709 tool_basename="${tool_specified##*/}"
22710 22710 if test "x$tool_basename" = "x$tool_specified"; then
22711 22711 # A command without a complete path is provided, search $PATH.
22712 22712 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
22713 22713 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
22714 22714 # Extract the first word of "$tool_basename", so it can be a program name with args.
22715 22715 set dummy $tool_basename; ac_word=$2
22716 22716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22717 22717 $as_echo_n "checking for $ac_word... " >&6; }
22718 22718 if ${ac_cv_path_TIME+:} false; then :
22719 22719 $as_echo_n "(cached) " >&6
22720 22720 else
22721 22721 case $TIME in
22722 22722 [\\/]* | ?:[\\/]*)
22723 22723 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22724 22724 ;;
22725 22725 *)
22726 22726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22727 22727 for as_dir in $PATH
22728 22728 do
22729 22729 IFS=$as_save_IFS
22730 22730 test -z "$as_dir" && as_dir=.
22731 22731 for ac_exec_ext in '' $ac_executable_extensions; do
22732 22732 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22733 22733 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22734 22734 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22735 22735 break 2
22736 22736 fi
22737 22737 done
22738 22738 done
22739 22739 IFS=$as_save_IFS
22740 22740
22741 22741 ;;
22742 22742 esac
22743 22743 fi
22744 22744 TIME=$ac_cv_path_TIME
22745 22745 if test -n "$TIME"; then
22746 22746 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22747 22747 $as_echo "$TIME" >&6; }
22748 22748 else
22749 22749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22750 22750 $as_echo "no" >&6; }
22751 22751 fi
22752 22752
22753 22753
22754 22754 if test "x$TIME" = x; then
22755 22755 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22756 22756 fi
22757 22757 else
22758 22758 # Otherwise we believe it is a complete path. Use it as it is.
22759 22759 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
22760 22760 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
22761 22761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22762 22762 $as_echo_n "checking for TIME... " >&6; }
22763 22763 if test ! -x "$tool_specified"; then
22764 22764 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22765 22765 $as_echo "not found" >&6; }
22766 22766 as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
22767 22767 fi
22768 22768 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22769 22769 $as_echo "$tool_specified" >&6; }
22770 22770 fi
22771 22771 fi
22772 22772 fi
22773 22773
22774 22774 fi
22775 22775
22776 22776
22777 22777
22778 22778
22779 22779 # Publish this variable in the help.
22780 22780
22781 22781
22782 22782 if [ -z "${DTRACE+x}" ]; then
22783 22783 # The variable is not set by user, try to locate tool using the code snippet
22784 22784 for ac_prog in dtrace
22785 22785 do
22786 22786 # Extract the first word of "$ac_prog", so it can be a program name with args.
22787 22787 set dummy $ac_prog; ac_word=$2
22788 22788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22789 22789 $as_echo_n "checking for $ac_word... " >&6; }
22790 22790 if ${ac_cv_path_DTRACE+:} false; then :
22791 22791 $as_echo_n "(cached) " >&6
22792 22792 else
22793 22793 case $DTRACE in
22794 22794 [\\/]* | ?:[\\/]*)
22795 22795 ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22796 22796 ;;
22797 22797 *)
22798 22798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22799 22799 for as_dir in $PATH
22800 22800 do
22801 22801 IFS=$as_save_IFS
22802 22802 test -z "$as_dir" && as_dir=.
22803 22803 for ac_exec_ext in '' $ac_executable_extensions; do
22804 22804 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22805 22805 ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22806 22806 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22807 22807 break 2
22808 22808 fi
22809 22809 done
22810 22810 done
22811 22811 IFS=$as_save_IFS
22812 22812
22813 22813 ;;
22814 22814 esac
22815 22815 fi
22816 22816 DTRACE=$ac_cv_path_DTRACE
22817 22817 if test -n "$DTRACE"; then
22818 22818 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22819 22819 $as_echo "$DTRACE" >&6; }
22820 22820 else
22821 22821 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22822 22822 $as_echo "no" >&6; }
22823 22823 fi
22824 22824
22825 22825
22826 22826 test -n "$DTRACE" && break
22827 22827 done
22828 22828
22829 22829 else
22830 22830 # The variable is set, but is it from the command line or the environment?
22831 22831
22832 22832 # Try to remove the string !DTRACE! from our list.
22833 22833 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
22834 22834 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22835 22835 # If it failed, the variable was not from the command line. Ignore it,
22836 22836 # but warn the user (except for BASH, which is always set by the calling BASH).
22837 22837 if test "xDTRACE" != xBASH; then
22838 22838 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
22839 22839 $as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
22840 22840 fi
22841 22841 # Try to locate tool using the code snippet
22842 22842 for ac_prog in dtrace
22843 22843 do
22844 22844 # Extract the first word of "$ac_prog", so it can be a program name with args.
22845 22845 set dummy $ac_prog; ac_word=$2
22846 22846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22847 22847 $as_echo_n "checking for $ac_word... " >&6; }
22848 22848 if ${ac_cv_path_DTRACE+:} false; then :
22849 22849 $as_echo_n "(cached) " >&6
22850 22850 else
22851 22851 case $DTRACE in
22852 22852 [\\/]* | ?:[\\/]*)
22853 22853 ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22854 22854 ;;
22855 22855 *)
22856 22856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22857 22857 for as_dir in $PATH
22858 22858 do
22859 22859 IFS=$as_save_IFS
22860 22860 test -z "$as_dir" && as_dir=.
22861 22861 for ac_exec_ext in '' $ac_executable_extensions; do
22862 22862 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22863 22863 ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22864 22864 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22865 22865 break 2
22866 22866 fi
22867 22867 done
22868 22868 done
22869 22869 IFS=$as_save_IFS
22870 22870
22871 22871 ;;
22872 22872 esac
22873 22873 fi
22874 22874 DTRACE=$ac_cv_path_DTRACE
22875 22875 if test -n "$DTRACE"; then
22876 22876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22877 22877 $as_echo "$DTRACE" >&6; }
22878 22878 else
22879 22879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22880 22880 $as_echo "no" >&6; }
22881 22881 fi
22882 22882
22883 22883
22884 22884 test -n "$DTRACE" && break
22885 22885 done
22886 22886
22887 22887 else
22888 22888 # If it succeeded, then it was overridden by the user. We will use it
22889 22889 # for the tool.
22890 22890
22891 22891 # First remove it from the list of overridden variables, so we can test
22892 22892 # for unknown variables in the end.
22893 22893 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22894 22894
22895 22895 # Check if we try to supply an empty value
22896 22896 if test "x$DTRACE" = x; then
22897 22897 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
22898 22898 $as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
22899 22899 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22900 22900 $as_echo_n "checking for DTRACE... " >&6; }
22901 22901 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22902 22902 $as_echo "disabled" >&6; }
22903 22903 else
22904 22904 # Check if the provided tool contains a complete path.
22905 22905 tool_specified="$DTRACE"
22906 22906 tool_basename="${tool_specified##*/}"
22907 22907 if test "x$tool_basename" = "x$tool_specified"; then
22908 22908 # A command without a complete path is provided, search $PATH.
22909 22909 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
22910 22910 $as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
22911 22911 # Extract the first word of "$tool_basename", so it can be a program name with args.
22912 22912 set dummy $tool_basename; ac_word=$2
22913 22913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22914 22914 $as_echo_n "checking for $ac_word... " >&6; }
22915 22915 if ${ac_cv_path_DTRACE+:} false; then :
22916 22916 $as_echo_n "(cached) " >&6
22917 22917 else
22918 22918 case $DTRACE in
22919 22919 [\\/]* | ?:[\\/]*)
22920 22920 ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22921 22921 ;;
22922 22922 *)
22923 22923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22924 22924 for as_dir in $PATH
22925 22925 do
22926 22926 IFS=$as_save_IFS
22927 22927 test -z "$as_dir" && as_dir=.
22928 22928 for ac_exec_ext in '' $ac_executable_extensions; do
22929 22929 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22930 22930 ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22931 22931 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22932 22932 break 2
22933 22933 fi
22934 22934 done
22935 22935 done
22936 22936 IFS=$as_save_IFS
22937 22937
22938 22938 ;;
22939 22939 esac
22940 22940 fi
22941 22941 DTRACE=$ac_cv_path_DTRACE
22942 22942 if test -n "$DTRACE"; then
22943 22943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22944 22944 $as_echo "$DTRACE" >&6; }
22945 22945 else
22946 22946 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22947 22947 $as_echo "no" >&6; }
22948 22948 fi
22949 22949
22950 22950
22951 22951 if test "x$DTRACE" = x; then
22952 22952 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22953 22953 fi
22954 22954 else
22955 22955 # Otherwise we believe it is a complete path. Use it as it is.
22956 22956 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
22957 22957 $as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
22958 22958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22959 22959 $as_echo_n "checking for DTRACE... " >&6; }
22960 22960 if test ! -x "$tool_specified"; then
22961 22961 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22962 22962 $as_echo "not found" >&6; }
22963 22963 as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
22964 22964 fi
22965 22965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22966 22966 $as_echo "$tool_specified" >&6; }
22967 22967 fi
22968 22968 fi
22969 22969 fi
22970 22970
22971 22971 fi
22972 22972
22973 22973
22974 22974
22975 22975
22976 22976 # Publish this variable in the help.
22977 22977
22978 22978
22979 22979 if [ -z "${PATCH+x}" ]; then
22980 22980 # The variable is not set by user, try to locate tool using the code snippet
22981 22981 for ac_prog in gpatch patch
22982 22982 do
22983 22983 # Extract the first word of "$ac_prog", so it can be a program name with args.
22984 22984 set dummy $ac_prog; ac_word=$2
22985 22985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22986 22986 $as_echo_n "checking for $ac_word... " >&6; }
22987 22987 if ${ac_cv_path_PATCH+:} false; then :
22988 22988 $as_echo_n "(cached) " >&6
22989 22989 else
22990 22990 case $PATCH in
22991 22991 [\\/]* | ?:[\\/]*)
22992 22992 ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22993 22993 ;;
22994 22994 *)
22995 22995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22996 22996 for as_dir in $PATH
22997 22997 do
22998 22998 IFS=$as_save_IFS
22999 22999 test -z "$as_dir" && as_dir=.
23000 23000 for ac_exec_ext in '' $ac_executable_extensions; do
23001 23001 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23002 23002 ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23003 23003 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23004 23004 break 2
23005 23005 fi
23006 23006 done
23007 23007 done
23008 23008 IFS=$as_save_IFS
23009 23009
23010 23010 ;;
23011 23011 esac
23012 23012 fi
23013 23013 PATCH=$ac_cv_path_PATCH
23014 23014 if test -n "$PATCH"; then
23015 23015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23016 23016 $as_echo "$PATCH" >&6; }
23017 23017 else
23018 23018 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23019 23019 $as_echo "no" >&6; }
23020 23020 fi
23021 23021
23022 23022
23023 23023 test -n "$PATCH" && break
23024 23024 done
23025 23025
23026 23026 else
23027 23027 # The variable is set, but is it from the command line or the environment?
23028 23028
23029 23029 # Try to remove the string !PATCH! from our list.
23030 23030 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
23031 23031 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23032 23032 # If it failed, the variable was not from the command line. Ignore it,
23033 23033 # but warn the user (except for BASH, which is always set by the calling BASH).
23034 23034 if test "xPATCH" != xBASH; then
23035 23035 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
23036 23036 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
23037 23037 fi
23038 23038 # Try to locate tool using the code snippet
23039 23039 for ac_prog in gpatch patch
23040 23040 do
23041 23041 # Extract the first word of "$ac_prog", so it can be a program name with args.
23042 23042 set dummy $ac_prog; ac_word=$2
23043 23043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23044 23044 $as_echo_n "checking for $ac_word... " >&6; }
23045 23045 if ${ac_cv_path_PATCH+:} false; then :
23046 23046 $as_echo_n "(cached) " >&6
23047 23047 else
23048 23048 case $PATCH in
23049 23049 [\\/]* | ?:[\\/]*)
23050 23050 ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23051 23051 ;;
23052 23052 *)
23053 23053 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23054 23054 for as_dir in $PATH
23055 23055 do
23056 23056 IFS=$as_save_IFS
23057 23057 test -z "$as_dir" && as_dir=.
23058 23058 for ac_exec_ext in '' $ac_executable_extensions; do
23059 23059 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23060 23060 ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23061 23061 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23062 23062 break 2
23063 23063 fi
23064 23064 done
23065 23065 done
23066 23066 IFS=$as_save_IFS
23067 23067
23068 23068 ;;
23069 23069 esac
23070 23070 fi
23071 23071 PATCH=$ac_cv_path_PATCH
23072 23072 if test -n "$PATCH"; then
23073 23073 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23074 23074 $as_echo "$PATCH" >&6; }
23075 23075 else
23076 23076 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23077 23077 $as_echo "no" >&6; }
23078 23078 fi
23079 23079
23080 23080
23081 23081 test -n "$PATCH" && break
23082 23082 done
23083 23083
23084 23084 else
23085 23085 # If it succeeded, then it was overridden by the user. We will use it
23086 23086 # for the tool.
23087 23087
23088 23088 # First remove it from the list of overridden variables, so we can test
23089 23089 # for unknown variables in the end.
23090 23090 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23091 23091
23092 23092 # Check if we try to supply an empty value
23093 23093 if test "x$PATCH" = x; then
23094 23094 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
23095 23095 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
23096 23096 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23097 23097 $as_echo_n "checking for PATCH... " >&6; }
23098 23098 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23099 23099 $as_echo "disabled" >&6; }
23100 23100 else
23101 23101 # Check if the provided tool contains a complete path.
23102 23102 tool_specified="$PATCH"
23103 23103 tool_basename="${tool_specified##*/}"
23104 23104 if test "x$tool_basename" = "x$tool_specified"; then
23105 23105 # A command without a complete path is provided, search $PATH.
23106 23106 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
23107 23107 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
23108 23108 # Extract the first word of "$tool_basename", so it can be a program name with args.
23109 23109 set dummy $tool_basename; ac_word=$2
23110 23110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23111 23111 $as_echo_n "checking for $ac_word... " >&6; }
23112 23112 if ${ac_cv_path_PATCH+:} false; then :
23113 23113 $as_echo_n "(cached) " >&6
23114 23114 else
23115 23115 case $PATCH in
23116 23116 [\\/]* | ?:[\\/]*)
23117 23117 ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23118 23118 ;;
23119 23119 *)
23120 23120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23121 23121 for as_dir in $PATH
23122 23122 do
23123 23123 IFS=$as_save_IFS
23124 23124 test -z "$as_dir" && as_dir=.
23125 23125 for ac_exec_ext in '' $ac_executable_extensions; do
23126 23126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23127 23127 ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23128 23128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23129 23129 break 2
23130 23130 fi
23131 23131 done
23132 23132 done
23133 23133 IFS=$as_save_IFS
23134 23134
23135 23135 ;;
23136 23136 esac
23137 23137 fi
23138 23138 PATCH=$ac_cv_path_PATCH
23139 23139 if test -n "$PATCH"; then
23140 23140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23141 23141 $as_echo "$PATCH" >&6; }
23142 23142 else
23143 23143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23144 23144 $as_echo "no" >&6; }
23145 23145 fi
23146 23146
23147 23147
23148 23148 if test "x$PATCH" = x; then
23149 23149 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23150 23150 fi
23151 23151 else
23152 23152 # Otherwise we believe it is a complete path. Use it as it is.
23153 23153 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
23154 23154 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
23155 23155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23156 23156 $as_echo_n "checking for PATCH... " >&6; }
23157 23157 if test ! -x "$tool_specified"; then
23158 23158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23159 23159 $as_echo "not found" >&6; }
23160 23160 as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
23161 23161 fi
23162 23162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23163 23163 $as_echo "$tool_specified" >&6; }
23164 23164 fi
23165 23165 fi
23166 23166 fi
23167 23167
23168 23168 fi
23169 23169
23170 23170
23171 23171 # Check if it's GNU time
23172 23172 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
23173 23173 if test "x$IS_GNU_TIME" != x; then
23174 23174 IS_GNU_TIME=yes
23175 23175 else
23176 23176 IS_GNU_TIME=no
23177 23177 fi
23178 23178
23179 23179
23180 23180 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
23181 23181
23182 23182
23183 23183
23184 23184 # Publish this variable in the help.
23185 23185
23186 23186
23187 23187 if [ -z "${DSYMUTIL+x}" ]; then
23188 23188 # The variable is not set by user, try to locate tool using the code snippet
23189 23189 for ac_prog in dsymutil
23190 23190 do
23191 23191 # Extract the first word of "$ac_prog", so it can be a program name with args.
23192 23192 set dummy $ac_prog; ac_word=$2
23193 23193 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23194 23194 $as_echo_n "checking for $ac_word... " >&6; }
23195 23195 if ${ac_cv_path_DSYMUTIL+:} false; then :
23196 23196 $as_echo_n "(cached) " >&6
23197 23197 else
23198 23198 case $DSYMUTIL in
23199 23199 [\\/]* | ?:[\\/]*)
23200 23200 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23201 23201 ;;
23202 23202 *)
23203 23203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23204 23204 for as_dir in $PATH
23205 23205 do
23206 23206 IFS=$as_save_IFS
23207 23207 test -z "$as_dir" && as_dir=.
23208 23208 for ac_exec_ext in '' $ac_executable_extensions; do
23209 23209 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23210 23210 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23211 23211 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23212 23212 break 2
23213 23213 fi
23214 23214 done
23215 23215 done
23216 23216 IFS=$as_save_IFS
23217 23217
23218 23218 ;;
23219 23219 esac
23220 23220 fi
23221 23221 DSYMUTIL=$ac_cv_path_DSYMUTIL
23222 23222 if test -n "$DSYMUTIL"; then
23223 23223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23224 23224 $as_echo "$DSYMUTIL" >&6; }
23225 23225 else
23226 23226 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23227 23227 $as_echo "no" >&6; }
23228 23228 fi
23229 23229
23230 23230
23231 23231 test -n "$DSYMUTIL" && break
23232 23232 done
23233 23233
23234 23234 else
23235 23235 # The variable is set, but is it from the command line or the environment?
23236 23236
23237 23237 # Try to remove the string !DSYMUTIL! from our list.
23238 23238 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
23239 23239 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23240 23240 # If it failed, the variable was not from the command line. Ignore it,
23241 23241 # but warn the user (except for BASH, which is always set by the calling BASH).
23242 23242 if test "xDSYMUTIL" != xBASH; then
23243 23243 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
23244 23244 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
23245 23245 fi
23246 23246 # Try to locate tool using the code snippet
23247 23247 for ac_prog in dsymutil
23248 23248 do
23249 23249 # Extract the first word of "$ac_prog", so it can be a program name with args.
23250 23250 set dummy $ac_prog; ac_word=$2
23251 23251 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23252 23252 $as_echo_n "checking for $ac_word... " >&6; }
23253 23253 if ${ac_cv_path_DSYMUTIL+:} false; then :
23254 23254 $as_echo_n "(cached) " >&6
23255 23255 else
23256 23256 case $DSYMUTIL in
23257 23257 [\\/]* | ?:[\\/]*)
23258 23258 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23259 23259 ;;
23260 23260 *)
23261 23261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23262 23262 for as_dir in $PATH
23263 23263 do
23264 23264 IFS=$as_save_IFS
23265 23265 test -z "$as_dir" && as_dir=.
23266 23266 for ac_exec_ext in '' $ac_executable_extensions; do
23267 23267 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23268 23268 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23269 23269 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23270 23270 break 2
23271 23271 fi
23272 23272 done
23273 23273 done
23274 23274 IFS=$as_save_IFS
23275 23275
23276 23276 ;;
23277 23277 esac
23278 23278 fi
23279 23279 DSYMUTIL=$ac_cv_path_DSYMUTIL
23280 23280 if test -n "$DSYMUTIL"; then
23281 23281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23282 23282 $as_echo "$DSYMUTIL" >&6; }
23283 23283 else
23284 23284 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23285 23285 $as_echo "no" >&6; }
23286 23286 fi
23287 23287
23288 23288
23289 23289 test -n "$DSYMUTIL" && break
23290 23290 done
23291 23291
23292 23292 else
23293 23293 # If it succeeded, then it was overridden by the user. We will use it
23294 23294 # for the tool.
23295 23295
23296 23296 # First remove it from the list of overridden variables, so we can test
23297 23297 # for unknown variables in the end.
23298 23298 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23299 23299
23300 23300 # Check if we try to supply an empty value
23301 23301 if test "x$DSYMUTIL" = x; then
23302 23302 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
23303 23303 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
23304 23304 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23305 23305 $as_echo_n "checking for DSYMUTIL... " >&6; }
23306 23306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23307 23307 $as_echo "disabled" >&6; }
23308 23308 else
23309 23309 # Check if the provided tool contains a complete path.
23310 23310 tool_specified="$DSYMUTIL"
23311 23311 tool_basename="${tool_specified##*/}"
23312 23312 if test "x$tool_basename" = "x$tool_specified"; then
23313 23313 # A command without a complete path is provided, search $PATH.
23314 23314 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
23315 23315 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
23316 23316 # Extract the first word of "$tool_basename", so it can be a program name with args.
23317 23317 set dummy $tool_basename; ac_word=$2
23318 23318 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23319 23319 $as_echo_n "checking for $ac_word... " >&6; }
23320 23320 if ${ac_cv_path_DSYMUTIL+:} false; then :
23321 23321 $as_echo_n "(cached) " >&6
23322 23322 else
23323 23323 case $DSYMUTIL in
23324 23324 [\\/]* | ?:[\\/]*)
23325 23325 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23326 23326 ;;
23327 23327 *)
23328 23328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23329 23329 for as_dir in $PATH
23330 23330 do
23331 23331 IFS=$as_save_IFS
23332 23332 test -z "$as_dir" && as_dir=.
23333 23333 for ac_exec_ext in '' $ac_executable_extensions; do
23334 23334 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23335 23335 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23336 23336 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23337 23337 break 2
23338 23338 fi
23339 23339 done
23340 23340 done
23341 23341 IFS=$as_save_IFS
23342 23342
23343 23343 ;;
23344 23344 esac
23345 23345 fi
23346 23346 DSYMUTIL=$ac_cv_path_DSYMUTIL
23347 23347 if test -n "$DSYMUTIL"; then
23348 23348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23349 23349 $as_echo "$DSYMUTIL" >&6; }
23350 23350 else
23351 23351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23352 23352 $as_echo "no" >&6; }
23353 23353 fi
23354 23354
23355 23355
23356 23356 if test "x$DSYMUTIL" = x; then
23357 23357 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23358 23358 fi
23359 23359 else
23360 23360 # Otherwise we believe it is a complete path. Use it as it is.
23361 23361 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
23362 23362 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
23363 23363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23364 23364 $as_echo_n "checking for DSYMUTIL... " >&6; }
23365 23365 if test ! -x "$tool_specified"; then
23366 23366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23367 23367 $as_echo "not found" >&6; }
23368 23368 as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
23369 23369 fi
23370 23370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23371 23371 $as_echo "$tool_specified" >&6; }
23372 23372 fi
23373 23373 fi
23374 23374 fi
23375 23375
23376 23376 fi
23377 23377
23378 23378
23379 23379
23380 23380 if test "x$DSYMUTIL" = x; then
23381 23381 as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
23382 23382 fi
23383 23383
23384 23384
23385 23385
23386 23386
23387 23387
23388 23388 # Publish this variable in the help.
23389 23389
23390 23390
23391 23391 if [ -z "${XATTR+x}" ]; then
23392 23392 # The variable is not set by user, try to locate tool using the code snippet
23393 23393 for ac_prog in xattr
23394 23394 do
23395 23395 # Extract the first word of "$ac_prog", so it can be a program name with args.
23396 23396 set dummy $ac_prog; ac_word=$2
23397 23397 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23398 23398 $as_echo_n "checking for $ac_word... " >&6; }
23399 23399 if ${ac_cv_path_XATTR+:} false; then :
23400 23400 $as_echo_n "(cached) " >&6
23401 23401 else
23402 23402 case $XATTR in
23403 23403 [\\/]* | ?:[\\/]*)
23404 23404 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23405 23405 ;;
23406 23406 *)
23407 23407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23408 23408 for as_dir in $PATH
23409 23409 do
23410 23410 IFS=$as_save_IFS
23411 23411 test -z "$as_dir" && as_dir=.
23412 23412 for ac_exec_ext in '' $ac_executable_extensions; do
23413 23413 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23414 23414 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23415 23415 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23416 23416 break 2
23417 23417 fi
23418 23418 done
23419 23419 done
23420 23420 IFS=$as_save_IFS
23421 23421
23422 23422 ;;
23423 23423 esac
23424 23424 fi
23425 23425 XATTR=$ac_cv_path_XATTR
23426 23426 if test -n "$XATTR"; then
23427 23427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23428 23428 $as_echo "$XATTR" >&6; }
23429 23429 else
23430 23430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23431 23431 $as_echo "no" >&6; }
23432 23432 fi
23433 23433
23434 23434
23435 23435 test -n "$XATTR" && break
23436 23436 done
23437 23437
23438 23438 else
23439 23439 # The variable is set, but is it from the command line or the environment?
23440 23440
23441 23441 # Try to remove the string !XATTR! from our list.
23442 23442 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
23443 23443 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23444 23444 # If it failed, the variable was not from the command line. Ignore it,
23445 23445 # but warn the user (except for BASH, which is always set by the calling BASH).
23446 23446 if test "xXATTR" != xBASH; then
23447 23447 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
23448 23448 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
23449 23449 fi
23450 23450 # Try to locate tool using the code snippet
23451 23451 for ac_prog in xattr
23452 23452 do
23453 23453 # Extract the first word of "$ac_prog", so it can be a program name with args.
23454 23454 set dummy $ac_prog; ac_word=$2
23455 23455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23456 23456 $as_echo_n "checking for $ac_word... " >&6; }
23457 23457 if ${ac_cv_path_XATTR+:} false; then :
23458 23458 $as_echo_n "(cached) " >&6
23459 23459 else
23460 23460 case $XATTR in
23461 23461 [\\/]* | ?:[\\/]*)
23462 23462 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23463 23463 ;;
23464 23464 *)
23465 23465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23466 23466 for as_dir in $PATH
23467 23467 do
23468 23468 IFS=$as_save_IFS
23469 23469 test -z "$as_dir" && as_dir=.
23470 23470 for ac_exec_ext in '' $ac_executable_extensions; do
23471 23471 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23472 23472 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23473 23473 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23474 23474 break 2
23475 23475 fi
23476 23476 done
23477 23477 done
23478 23478 IFS=$as_save_IFS
23479 23479
23480 23480 ;;
23481 23481 esac
23482 23482 fi
23483 23483 XATTR=$ac_cv_path_XATTR
23484 23484 if test -n "$XATTR"; then
23485 23485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23486 23486 $as_echo "$XATTR" >&6; }
23487 23487 else
23488 23488 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23489 23489 $as_echo "no" >&6; }
23490 23490 fi
23491 23491
23492 23492
23493 23493 test -n "$XATTR" && break
23494 23494 done
23495 23495
23496 23496 else
23497 23497 # If it succeeded, then it was overridden by the user. We will use it
23498 23498 # for the tool.
23499 23499
23500 23500 # First remove it from the list of overridden variables, so we can test
23501 23501 # for unknown variables in the end.
23502 23502 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23503 23503
23504 23504 # Check if we try to supply an empty value
23505 23505 if test "x$XATTR" = x; then
23506 23506 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
23507 23507 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
23508 23508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23509 23509 $as_echo_n "checking for XATTR... " >&6; }
23510 23510 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23511 23511 $as_echo "disabled" >&6; }
23512 23512 else
23513 23513 # Check if the provided tool contains a complete path.
23514 23514 tool_specified="$XATTR"
23515 23515 tool_basename="${tool_specified##*/}"
23516 23516 if test "x$tool_basename" = "x$tool_specified"; then
23517 23517 # A command without a complete path is provided, search $PATH.
23518 23518 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
23519 23519 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
23520 23520 # Extract the first word of "$tool_basename", so it can be a program name with args.
23521 23521 set dummy $tool_basename; ac_word=$2
23522 23522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23523 23523 $as_echo_n "checking for $ac_word... " >&6; }
23524 23524 if ${ac_cv_path_XATTR+:} false; then :
23525 23525 $as_echo_n "(cached) " >&6
23526 23526 else
23527 23527 case $XATTR in
23528 23528 [\\/]* | ?:[\\/]*)
23529 23529 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23530 23530 ;;
23531 23531 *)
23532 23532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23533 23533 for as_dir in $PATH
23534 23534 do
23535 23535 IFS=$as_save_IFS
23536 23536 test -z "$as_dir" && as_dir=.
23537 23537 for ac_exec_ext in '' $ac_executable_extensions; do
23538 23538 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23539 23539 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23540 23540 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23541 23541 break 2
23542 23542 fi
23543 23543 done
23544 23544 done
23545 23545 IFS=$as_save_IFS
23546 23546
23547 23547 ;;
23548 23548 esac
23549 23549 fi
23550 23550 XATTR=$ac_cv_path_XATTR
23551 23551 if test -n "$XATTR"; then
23552 23552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23553 23553 $as_echo "$XATTR" >&6; }
23554 23554 else
23555 23555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23556 23556 $as_echo "no" >&6; }
23557 23557 fi
23558 23558
23559 23559
23560 23560 if test "x$XATTR" = x; then
23561 23561 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23562 23562 fi
23563 23563 else
23564 23564 # Otherwise we believe it is a complete path. Use it as it is.
23565 23565 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
23566 23566 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
23567 23567 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23568 23568 $as_echo_n "checking for XATTR... " >&6; }
23569 23569 if test ! -x "$tool_specified"; then
23570 23570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23571 23571 $as_echo "not found" >&6; }
23572 23572 as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
23573 23573 fi
23574 23574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23575 23575 $as_echo "$tool_specified" >&6; }
23576 23576 fi
23577 23577 fi
23578 23578 fi
23579 23579
23580 23580 fi
23581 23581
23582 23582
23583 23583
23584 23584 if test "x$XATTR" = x; then
23585 23585 as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
23586 23586 fi
23587 23587
23588 23588
23589 23589
23590 23590
23591 23591 # Publish this variable in the help.
23592 23592
23593 23593
23594 23594 if [ -z "${CODESIGN+x}" ]; then
23595 23595 # The variable is not set by user, try to locate tool using the code snippet
23596 23596 for ac_prog in codesign
23597 23597 do
23598 23598 # Extract the first word of "$ac_prog", so it can be a program name with args.
23599 23599 set dummy $ac_prog; ac_word=$2
23600 23600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23601 23601 $as_echo_n "checking for $ac_word... " >&6; }
23602 23602 if ${ac_cv_path_CODESIGN+:} false; then :
23603 23603 $as_echo_n "(cached) " >&6
23604 23604 else
23605 23605 case $CODESIGN in
23606 23606 [\\/]* | ?:[\\/]*)
23607 23607 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23608 23608 ;;
23609 23609 *)
23610 23610 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23611 23611 for as_dir in $PATH
23612 23612 do
23613 23613 IFS=$as_save_IFS
23614 23614 test -z "$as_dir" && as_dir=.
23615 23615 for ac_exec_ext in '' $ac_executable_extensions; do
23616 23616 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23617 23617 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23618 23618 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23619 23619 break 2
23620 23620 fi
23621 23621 done
23622 23622 done
23623 23623 IFS=$as_save_IFS
23624 23624
23625 23625 ;;
23626 23626 esac
23627 23627 fi
23628 23628 CODESIGN=$ac_cv_path_CODESIGN
23629 23629 if test -n "$CODESIGN"; then
23630 23630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23631 23631 $as_echo "$CODESIGN" >&6; }
23632 23632 else
23633 23633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23634 23634 $as_echo "no" >&6; }
23635 23635 fi
23636 23636
23637 23637
23638 23638 test -n "$CODESIGN" && break
23639 23639 done
23640 23640
23641 23641 else
23642 23642 # The variable is set, but is it from the command line or the environment?
23643 23643
23644 23644 # Try to remove the string !CODESIGN! from our list.
23645 23645 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
23646 23646 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23647 23647 # If it failed, the variable was not from the command line. Ignore it,
23648 23648 # but warn the user (except for BASH, which is always set by the calling BASH).
23649 23649 if test "xCODESIGN" != xBASH; then
23650 23650 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
23651 23651 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
23652 23652 fi
23653 23653 # Try to locate tool using the code snippet
23654 23654 for ac_prog in codesign
23655 23655 do
23656 23656 # Extract the first word of "$ac_prog", so it can be a program name with args.
23657 23657 set dummy $ac_prog; ac_word=$2
23658 23658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23659 23659 $as_echo_n "checking for $ac_word... " >&6; }
23660 23660 if ${ac_cv_path_CODESIGN+:} false; then :
23661 23661 $as_echo_n "(cached) " >&6
23662 23662 else
23663 23663 case $CODESIGN in
23664 23664 [\\/]* | ?:[\\/]*)
23665 23665 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23666 23666 ;;
23667 23667 *)
23668 23668 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23669 23669 for as_dir in $PATH
23670 23670 do
23671 23671 IFS=$as_save_IFS
23672 23672 test -z "$as_dir" && as_dir=.
23673 23673 for ac_exec_ext in '' $ac_executable_extensions; do
23674 23674 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23675 23675 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23676 23676 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23677 23677 break 2
23678 23678 fi
23679 23679 done
23680 23680 done
23681 23681 IFS=$as_save_IFS
23682 23682
23683 23683 ;;
23684 23684 esac
23685 23685 fi
23686 23686 CODESIGN=$ac_cv_path_CODESIGN
23687 23687 if test -n "$CODESIGN"; then
23688 23688 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23689 23689 $as_echo "$CODESIGN" >&6; }
23690 23690 else
23691 23691 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23692 23692 $as_echo "no" >&6; }
23693 23693 fi
23694 23694
23695 23695
23696 23696 test -n "$CODESIGN" && break
23697 23697 done
23698 23698
23699 23699 else
23700 23700 # If it succeeded, then it was overridden by the user. We will use it
23701 23701 # for the tool.
23702 23702
23703 23703 # First remove it from the list of overridden variables, so we can test
23704 23704 # for unknown variables in the end.
23705 23705 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23706 23706
23707 23707 # Check if we try to supply an empty value
23708 23708 if test "x$CODESIGN" = x; then
23709 23709 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
23710 23710 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
23711 23711 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23712 23712 $as_echo_n "checking for CODESIGN... " >&6; }
23713 23713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23714 23714 $as_echo "disabled" >&6; }
23715 23715 else
23716 23716 # Check if the provided tool contains a complete path.
23717 23717 tool_specified="$CODESIGN"
23718 23718 tool_basename="${tool_specified##*/}"
23719 23719 if test "x$tool_basename" = "x$tool_specified"; then
23720 23720 # A command without a complete path is provided, search $PATH.
23721 23721 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
23722 23722 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
23723 23723 # Extract the first word of "$tool_basename", so it can be a program name with args.
23724 23724 set dummy $tool_basename; ac_word=$2
23725 23725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23726 23726 $as_echo_n "checking for $ac_word... " >&6; }
23727 23727 if ${ac_cv_path_CODESIGN+:} false; then :
23728 23728 $as_echo_n "(cached) " >&6
23729 23729 else
23730 23730 case $CODESIGN in
23731 23731 [\\/]* | ?:[\\/]*)
23732 23732 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23733 23733 ;;
23734 23734 *)
23735 23735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23736 23736 for as_dir in $PATH
23737 23737 do
23738 23738 IFS=$as_save_IFS
23739 23739 test -z "$as_dir" && as_dir=.
23740 23740 for ac_exec_ext in '' $ac_executable_extensions; do
23741 23741 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23742 23742 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23743 23743 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23744 23744 break 2
23745 23745 fi
23746 23746 done
23747 23747 done
23748 23748 IFS=$as_save_IFS
23749 23749
23750 23750 ;;
23751 23751 esac
23752 23752 fi
23753 23753 CODESIGN=$ac_cv_path_CODESIGN
23754 23754 if test -n "$CODESIGN"; then
23755 23755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23756 23756 $as_echo "$CODESIGN" >&6; }
23757 23757 else
23758 23758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23759 23759 $as_echo "no" >&6; }
23760 23760 fi
23761 23761
23762 23762
23763 23763 if test "x$CODESIGN" = x; then
23764 23764 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23765 23765 fi
23766 23766 else
23767 23767 # Otherwise we believe it is a complete path. Use it as it is.
23768 23768 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
23769 23769 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
23770 23770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23771 23771 $as_echo_n "checking for CODESIGN... " >&6; }
23772 23772 if test ! -x "$tool_specified"; then
23773 23773 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23774 23774 $as_echo "not found" >&6; }
23775 23775 as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
23776 23776 fi
23777 23777 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23778 23778 $as_echo "$tool_specified" >&6; }
23779 23779 fi
23780 23780 fi
23781 23781 fi
23782 23782
23783 23783 fi
23784 23784
23785 23785
23786 23786 if test "x$CODESIGN" != "x"; then
23787 23787 # Verify that the openjdk_codesign certificate is present
23788 23788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
23789 23789 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
23790 23790 $RM codesign-testfile
23791 23791 $TOUCH codesign-testfile
23792 23792 $CODESIGN -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
23793 23793 $RM codesign-testfile
23794 23794 if test "x$CODESIGN" = x; then
23795 23795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23796 23796 $as_echo "no" >&6; }
23797 23797 else
23798 23798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23799 23799 $as_echo "yes" >&6; }
23800 23800 fi
23801 23801 fi
23802 23802
23803 23803
23804 23804
23805 23805 # Publish this variable in the help.
23806 23806
23807 23807
23808 23808 if [ -z "${SETFILE+x}" ]; then
23809 23809 # The variable is not set by user, try to locate tool using the code snippet
23810 23810 for ac_prog in SetFile
23811 23811 do
23812 23812 # Extract the first word of "$ac_prog", so it can be a program name with args.
23813 23813 set dummy $ac_prog; ac_word=$2
23814 23814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23815 23815 $as_echo_n "checking for $ac_word... " >&6; }
23816 23816 if ${ac_cv_path_SETFILE+:} false; then :
23817 23817 $as_echo_n "(cached) " >&6
23818 23818 else
23819 23819 case $SETFILE in
23820 23820 [\\/]* | ?:[\\/]*)
23821 23821 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23822 23822 ;;
23823 23823 *)
23824 23824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23825 23825 for as_dir in $PATH
23826 23826 do
23827 23827 IFS=$as_save_IFS
23828 23828 test -z "$as_dir" && as_dir=.
23829 23829 for ac_exec_ext in '' $ac_executable_extensions; do
23830 23830 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23831 23831 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23832 23832 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23833 23833 break 2
23834 23834 fi
23835 23835 done
23836 23836 done
23837 23837 IFS=$as_save_IFS
23838 23838
23839 23839 ;;
23840 23840 esac
23841 23841 fi
23842 23842 SETFILE=$ac_cv_path_SETFILE
23843 23843 if test -n "$SETFILE"; then
23844 23844 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23845 23845 $as_echo "$SETFILE" >&6; }
23846 23846 else
23847 23847 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23848 23848 $as_echo "no" >&6; }
23849 23849 fi
23850 23850
23851 23851
23852 23852 test -n "$SETFILE" && break
23853 23853 done
23854 23854
23855 23855 else
23856 23856 # The variable is set, but is it from the command line or the environment?
23857 23857
23858 23858 # Try to remove the string !SETFILE! from our list.
23859 23859 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
23860 23860 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23861 23861 # If it failed, the variable was not from the command line. Ignore it,
23862 23862 # but warn the user (except for BASH, which is always set by the calling BASH).
23863 23863 if test "xSETFILE" != xBASH; then
23864 23864 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
23865 23865 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
23866 23866 fi
23867 23867 # Try to locate tool using the code snippet
23868 23868 for ac_prog in SetFile
23869 23869 do
23870 23870 # Extract the first word of "$ac_prog", so it can be a program name with args.
23871 23871 set dummy $ac_prog; ac_word=$2
23872 23872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23873 23873 $as_echo_n "checking for $ac_word... " >&6; }
23874 23874 if ${ac_cv_path_SETFILE+:} false; then :
23875 23875 $as_echo_n "(cached) " >&6
23876 23876 else
23877 23877 case $SETFILE in
23878 23878 [\\/]* | ?:[\\/]*)
23879 23879 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23880 23880 ;;
23881 23881 *)
23882 23882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23883 23883 for as_dir in $PATH
23884 23884 do
23885 23885 IFS=$as_save_IFS
23886 23886 test -z "$as_dir" && as_dir=.
23887 23887 for ac_exec_ext in '' $ac_executable_extensions; do
23888 23888 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23889 23889 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23890 23890 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23891 23891 break 2
23892 23892 fi
23893 23893 done
23894 23894 done
23895 23895 IFS=$as_save_IFS
23896 23896
23897 23897 ;;
23898 23898 esac
23899 23899 fi
23900 23900 SETFILE=$ac_cv_path_SETFILE
23901 23901 if test -n "$SETFILE"; then
23902 23902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23903 23903 $as_echo "$SETFILE" >&6; }
23904 23904 else
23905 23905 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23906 23906 $as_echo "no" >&6; }
23907 23907 fi
23908 23908
23909 23909
23910 23910 test -n "$SETFILE" && break
23911 23911 done
23912 23912
23913 23913 else
23914 23914 # If it succeeded, then it was overridden by the user. We will use it
23915 23915 # for the tool.
23916 23916
23917 23917 # First remove it from the list of overridden variables, so we can test
23918 23918 # for unknown variables in the end.
23919 23919 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23920 23920
23921 23921 # Check if we try to supply an empty value
23922 23922 if test "x$SETFILE" = x; then
23923 23923 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
23924 23924 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
23925 23925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23926 23926 $as_echo_n "checking for SETFILE... " >&6; }
23927 23927 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23928 23928 $as_echo "disabled" >&6; }
23929 23929 else
23930 23930 # Check if the provided tool contains a complete path.
23931 23931 tool_specified="$SETFILE"
23932 23932 tool_basename="${tool_specified##*/}"
23933 23933 if test "x$tool_basename" = "x$tool_specified"; then
23934 23934 # A command without a complete path is provided, search $PATH.
23935 23935 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
23936 23936 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
23937 23937 # Extract the first word of "$tool_basename", so it can be a program name with args.
23938 23938 set dummy $tool_basename; ac_word=$2
23939 23939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23940 23940 $as_echo_n "checking for $ac_word... " >&6; }
23941 23941 if ${ac_cv_path_SETFILE+:} false; then :
23942 23942 $as_echo_n "(cached) " >&6
23943 23943 else
23944 23944 case $SETFILE in
23945 23945 [\\/]* | ?:[\\/]*)
23946 23946 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23947 23947 ;;
23948 23948 *)
23949 23949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23950 23950 for as_dir in $PATH
23951 23951 do
23952 23952 IFS=$as_save_IFS
23953 23953 test -z "$as_dir" && as_dir=.
23954 23954 for ac_exec_ext in '' $ac_executable_extensions; do
23955 23955 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23956 23956 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23957 23957 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23958 23958 break 2
23959 23959 fi
23960 23960 done
23961 23961 done
23962 23962 IFS=$as_save_IFS
23963 23963
23964 23964 ;;
23965 23965 esac
23966 23966 fi
23967 23967 SETFILE=$ac_cv_path_SETFILE
23968 23968 if test -n "$SETFILE"; then
23969 23969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23970 23970 $as_echo "$SETFILE" >&6; }
23971 23971 else
23972 23972 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23973 23973 $as_echo "no" >&6; }
23974 23974 fi
23975 23975
23976 23976
23977 23977 if test "x$SETFILE" = x; then
23978 23978 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23979 23979 fi
23980 23980 else
23981 23981 # Otherwise we believe it is a complete path. Use it as it is.
23982 23982 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
23983 23983 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
23984 23984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23985 23985 $as_echo_n "checking for SETFILE... " >&6; }
23986 23986 if test ! -x "$tool_specified"; then
23987 23987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23988 23988 $as_echo "not found" >&6; }
23989 23989 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
23990 23990 fi
23991 23991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23992 23992 $as_echo "$tool_specified" >&6; }
23993 23993 fi
23994 23994 fi
23995 23995 fi
23996 23996
23997 23997 fi
23998 23998
23999 23999
24000 24000
24001 24001 if test "x$SETFILE" = x; then
24002 24002 as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
24003 24003 fi
24004 24004
24005 24005
24006 24006 fi
24007 24007
24008 24008
24009 24009 # Test if bash supports pipefail.
24010 24010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
24011 24011 $as_echo_n "checking if bash supports pipefail... " >&6; }
24012 24012 if ${BASH} -c 'set -o pipefail'; then
24013 24013 BASH_ARGS="$BASH_ARGS -o pipefail"
24014 24014 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24015 24015 $as_echo "yes" >&6; }
24016 24016 else
24017 24017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24018 24018 $as_echo "no" >&6; }
24019 24019 fi
24020 24020
24021 24021 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
24022 24022 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
24023 24023 if ${BASH} -e -c 'true'; then
24024 24024 BASH_ARGS="$BASH_ARGS -e"
24025 24025 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24026 24026 $as_echo "yes" >&6; }
24027 24027 else
24028 24028 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24029 24029 $as_echo "no" >&6; }
24030 24030 fi
24031 24031
24032 24032
24033 24033
24034 24034
24035 24035 # Check if pkg-config is available.
24036 24036
24037 24037
24038 24038 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
24039 24039 if test -n "$ac_tool_prefix"; then
24040 24040 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
24041 24041 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
24042 24042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24043 24043 $as_echo_n "checking for $ac_word... " >&6; }
24044 24044 if ${ac_cv_path_PKG_CONFIG+:} false; then :
24045 24045 $as_echo_n "(cached) " >&6
24046 24046 else
24047 24047 case $PKG_CONFIG in
24048 24048 [\\/]* | ?:[\\/]*)
24049 24049 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
24050 24050 ;;
24051 24051 *)
24052 24052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24053 24053 for as_dir in $PATH
24054 24054 do
24055 24055 IFS=$as_save_IFS
24056 24056 test -z "$as_dir" && as_dir=.
24057 24057 for ac_exec_ext in '' $ac_executable_extensions; do
24058 24058 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24059 24059 ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24060 24060 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24061 24061 break 2
24062 24062 fi
24063 24063 done
24064 24064 done
24065 24065 IFS=$as_save_IFS
24066 24066
24067 24067 ;;
24068 24068 esac
24069 24069 fi
24070 24070 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
24071 24071 if test -n "$PKG_CONFIG"; then
24072 24072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
24073 24073 $as_echo "$PKG_CONFIG" >&6; }
24074 24074 else
24075 24075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24076 24076 $as_echo "no" >&6; }
24077 24077 fi
24078 24078
24079 24079
24080 24080 fi
24081 24081 if test -z "$ac_cv_path_PKG_CONFIG"; then
24082 24082 ac_pt_PKG_CONFIG=$PKG_CONFIG
24083 24083 # Extract the first word of "pkg-config", so it can be a program name with args.
24084 24084 set dummy pkg-config; ac_word=$2
24085 24085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24086 24086 $as_echo_n "checking for $ac_word... " >&6; }
24087 24087 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
24088 24088 $as_echo_n "(cached) " >&6
24089 24089 else
24090 24090 case $ac_pt_PKG_CONFIG in
24091 24091 [\\/]* | ?:[\\/]*)
24092 24092 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
24093 24093 ;;
24094 24094 *)
24095 24095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24096 24096 for as_dir in $PATH
24097 24097 do
24098 24098 IFS=$as_save_IFS
24099 24099 test -z "$as_dir" && as_dir=.
24100 24100 for ac_exec_ext in '' $ac_executable_extensions; do
24101 24101 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24102 24102 ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24103 24103 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24104 24104 break 2
24105 24105 fi
24106 24106 done
24107 24107 done
24108 24108 IFS=$as_save_IFS
24109 24109
24110 24110 ;;
24111 24111 esac
24112 24112 fi
24113 24113 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
24114 24114 if test -n "$ac_pt_PKG_CONFIG"; then
24115 24115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
24116 24116 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
24117 24117 else
24118 24118 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24119 24119 $as_echo "no" >&6; }
24120 24120 fi
24121 24121
24122 24122 if test "x$ac_pt_PKG_CONFIG" = x; then
24123 24123 PKG_CONFIG=""
24124 24124 else
24125 24125 case $cross_compiling:$ac_tool_warned in
24126 24126 yes:)
24127 24127 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
24128 24128 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
24129 24129 ac_tool_warned=yes ;;
24130 24130 esac
24131 24131 PKG_CONFIG=$ac_pt_PKG_CONFIG
24132 24132 fi
24133 24133 else
24134 24134 PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
24135 24135 fi
24136 24136
24137 24137 fi
24138 24138 if test -n "$PKG_CONFIG"; then
24139 24139 _pkg_min_version=0.9.0
24140 24140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
24141 24141 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
24142 24142 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
24143 24143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24144 24144 $as_echo "yes" >&6; }
24145 24145 else
24146 24146 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24147 24147 $as_echo "no" >&6; }
24148 24148 PKG_CONFIG=""
24149 24149 fi
24150 24150
24151 24151 fi
24152 24152
24153 24153 # After basic tools have been setup, we can check build os specific details.
24154 24154
24155 24155 ###############################################################################
24156 24156
24157 24157 # Note that this is the build platform OS version!
24158 24158
24159 24159 OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
24160 24160 OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
24161 24161 OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
24162 24162 OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
24163 24163
24164 24164
24165 24165
24166 24166
24167 24167
24168 24168 # Misc basic settings
24169 24169
24170 24170
24171 24171 # Check whether --with-default-make-target was given.
24172 24172 if test "${with_default_make_target+set}" = set; then :
24173 24173 withval=$with_default_make_target;
24174 24174 fi
24175 24175
24176 24176 if test "x$with_default_make_target" = "x" \
24177 24177 || test "x$with_default_make_target" = "xyes"; then
24178 24178 DEFAULT_MAKE_TARGET="exploded-image"
24179 24179 elif test "x$with_default_make_target" = "xno"; then
24180 24180 as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
24181 24181 else
24182 24182 DEFAULT_MAKE_TARGET="$with_default_make_target"
24183 24183 fi
24184 24184
24185 24185
24186 24186
24187 24187
24188 24188 ###############################################################################
24189 24189 #
24190 24190 # Determine OpenJDK variants, options and version numbers.
24191 24191 #
24192 24192 ###############################################################################
24193 24193
24194 24194 # We need build & target for this.
24195 24195
24196 24196 # Should we build a JDK/JVM with headful support (ie a graphical ui)?
24197 24197 # We always build headless support.
24198 24198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
24199 24199 $as_echo_n "checking headful support... " >&6; }
24200 24200 # Check whether --enable-headful was given.
24201 24201 if test "${enable_headful+set}" = set; then :
24202 24202 enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
24203 24203 else
24204 24204 SUPPORT_HEADFUL=yes
24205 24205 fi
24206 24206
24207 24207
24208 24208 SUPPORT_HEADLESS=yes
24209 24209 BUILD_HEADLESS="BUILD_HEADLESS:=true"
24210 24210
24211 24211 if test "x$SUPPORT_HEADFUL" = xyes; then
24212 24212 # We are building both headful and headless.
24213 24213 headful_msg="include support for both headful and headless"
24214 24214 fi
24215 24215
24216 24216 if test "x$SUPPORT_HEADFUL" = xno; then
24217 24217 # Thus we are building headless only.
24218 24218 BUILD_HEADLESS="BUILD_HEADLESS:=true"
24219 24219 headful_msg="headless only"
24220 24220 fi
24221 24221
24222 24222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
24223 24223 $as_echo "$headful_msg" >&6; }
24224 24224
24225 24225
24226 24226
24227 24227
24228 24228
24229 24229 # Choose cacerts source file
24230 24230
24231 24231 # Check whether --with-cacerts-file was given.
24232 24232 if test "${with_cacerts_file+set}" = set; then :
24233 24233 withval=$with_cacerts_file;
24234 24234 fi
24235 24235
24236 24236 if test "x$with_cacerts_file" != x; then
24237 24237 CACERTS_FILE=$with_cacerts_file
24238 24238 fi
24239 24239
24240 24240
24241 24241 # Enable or disable unlimited crypto
24242 24242 # Check whether --enable-unlimited-crypto was given.
24243 24243 if test "${enable_unlimited_crypto+set}" = set; then :
24244 24244 enableval=$enable_unlimited_crypto;
24245 24245 else
24246 24246 enable_unlimited_crypto=no
24247 24247 fi
24248 24248
24249 24249 if test "x$enable_unlimited_crypto" = "xyes"; then
24250 24250 UNLIMITED_CRYPTO=true
24251 24251 else
24252 24252 UNLIMITED_CRYPTO=false
24253 24253 fi
24254 24254
24255 24255
24256 24256 # Should we build the serviceability agent (SA)?
24257 24257 INCLUDE_SA=true
24258 24258 if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
24259 24259 INCLUDE_SA=false
24260 24260 fi
24261 24261 if test "x$OPENJDK_TARGET_OS" = xaix ; then
24262 24262 INCLUDE_SA=false
24263 24263 fi
24264 24264
24265 24265
24266 24266 # Compress jars
24267 24267 COMPRESS_JARS=false
24268 24268
24269 24269
24270 24270
24271 24271 # Setup default copyright year. Mostly overridden when building close to a new year.
24272 24272
24273 24273 # Check whether --with-copyright-year was given.
24274 24274 if test "${with_copyright_year+set}" = set; then :
24275 24275 withval=$with_copyright_year;
24276 24276 fi
24277 24277
24278 24278 if test "x$with_copyright_year" = xyes; then
24279 24279 as_fn_error $? "Copyright year must have a value" "$LINENO" 5
24280 24280 elif test "x$with_copyright_year" != x; then
24281 24281 COPYRIGHT_YEAR="$with_copyright_year"
24282 24282 else
24283 24283 COPYRIGHT_YEAR=`$DATE +'%Y'`
24284 24284 fi
24285 24285
24286 24286
24287 24287
24288 24288 # Check whether --enable-keep-packaged-modules was given.
24289 24289 if test "${enable_keep_packaged_modules+set}" = set; then :
24290 24290 enableval=$enable_keep_packaged_modules;
24291 24291 fi
24292 24292
24293 24293
24294 24294 if test "x$enable_keep_packaged_modules" = "xyes"; then
24295 24295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24296 24296 $as_echo_n "checking if packaged modules are kept... " >&6; }
24297 24297 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24298 24298 $as_echo "yes" >&6; }
24299 24299 JLINK_KEEP_PACKAGED_MODULES=true
24300 24300 elif test "x$enable_keep_packaged_modules" = "xno"; then
24301 24301 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24302 24302 $as_echo_n "checking if packaged modules are kept... " >&6; }
24303 24303 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24304 24304 $as_echo "no" >&6; }
24305 24305 JLINK_KEEP_PACKAGED_MODULES=false
24306 24306 elif test "x$enable_keep_packaged_modules" = "x"; then
24307 24307 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
24308 24308 $as_echo "yes (default)" >&6; }
24309 24309 JLINK_KEEP_PACKAGED_MODULES=true
24310 24310 else
24311 24311 as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
24312 24312 fi
24313 24313
24314 24314
24315 24315
24316 24316
24317 24317 # Warn user that old version arguments are deprecated.
24318 24318
24319 24319
24320 24320 # Check whether --with-milestone was given.
24321 24321 if test "${with_milestone+set}" = set; then :
24322 24322 withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
24323 24323 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
24324 24324 fi
24325 24325
24326 24326
24327 24327
24328 24328
24329 24329 # Check whether --with-update-version was given.
24330 24330 if test "${with_update_version+set}" = set; then :
24331 24331 withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
24332 24332 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
24333 24333 fi
24334 24334
24335 24335
24336 24336
24337 24337
24338 24338 # Check whether --with-user-release-suffix was given.
24339 24339 if test "${with_user_release_suffix+set}" = set; then :
24340 24340 withval=$with_user_release_suffix; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&5
24341 24341 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
24342 24342 fi
24343 24343
24344 24344
24345 24345
24346 24346
24347 24347 # Check whether --with-build-number was given.
24348 24348 if test "${with_build_number+set}" = set; then :
24349 24349 withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
24350 24350 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
24351 24351 fi
24352 24352
24353 24353
24354 24354
24355 24355 # Source the version numbers file
24356 24356 . $AUTOCONF_DIR/version-numbers
24357 24357
24358 24358 # Some non-version number information is set in that file
24359 24359
24360 24360
24361 24361
24362 24362
24363 24363
24364 24364
24365 24365
24366 24366
24367 24367
24368 24368 # Override version from arguments
24369 24369
24370 24370 # If --with-version-string is set, process it first. It is possible to
24371 24371 # override parts with more specific flags, since these are processed later.
24372 24372
24373 24373 # Check whether --with-version-string was given.
24374 24374 if test "${with_version_string+set}" = set; then :
24375 24375 withval=$with_version_string;
24376 24376 fi
24377 24377
24378 24378 if test "x$with_version_string" = xyes; then
24379 24379 as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
24380 24380 elif test "x$with_version_string" != x; then
24381 24381 # Additional [] needed to keep m4 from mangling shell constructs.
24382 24382 if [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
24383 24383 VERSION_MAJOR=${BASH_REMATCH[1]}
24384 24384 VERSION_MINOR=${BASH_REMATCH[3]}
24385 24385 VERSION_SECURITY=${BASH_REMATCH[5]}
24386 24386 VERSION_PATCH=${BASH_REMATCH[7]}
24387 24387 VERSION_PRE=${BASH_REMATCH[9]}
24388 24388 version_plus_separator=${BASH_REMATCH[11]}
24389 24389 VERSION_BUILD=${BASH_REMATCH[12]}
24390 24390 VERSION_OPT=${BASH_REMATCH[14]}
24391 24391 # Unspecified numerical fields are interpreted as 0.
24392 24392 if test "x$VERSION_MINOR" = x; then
24393 24393 VERSION_MINOR=0
24394 24394 fi
24395 24395 if test "x$VERSION_SECURITY" = x; then
24396 24396 VERSION_SECURITY=0
24397 24397 fi
24398 24398 if test "x$VERSION_PATCH" = x; then
24399 24399 VERSION_PATCH=0
24400 24400 fi
24401 24401 if test "x$version_plus_separator" != x \
24402 24402 && test "x$VERSION_BUILD$VERSION_OPT" = x; then
24403 24403 as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
24404 24404 fi
24405 24405 # Stop the version part process from setting default values.
24406 24406 # We still allow them to explicitely override though.
24407 24407 NO_DEFAULT_VERSION_PARTS=true
24408 24408 else
24409 24409 as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
24410 24410 fi
24411 24411 fi
24412 24412
24413 24413
24414 24414 # Check whether --with-version-pre was given.
24415 24415 if test "${with_version_pre+set}" = set; then :
24416 24416 withval=$with_version_pre; with_version_pre_present=true
24417 24417 else
24418 24418 with_version_pre_present=false
24419 24419 fi
24420 24420
24421 24421
24422 24422 if test "x$with_version_pre_present" = xtrue; then
24423 24423 if test "x$with_version_pre" = xyes; then
24424 24424 as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
24425 24425 elif test "x$with_version_pre" = xno; then
24426 24426 # Interpret --without-* as empty string instead of the literal "no"
24427 24427 VERSION_PRE=
24428 24428 else
24429 24429 # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
24430 24430 VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
24431 24431 if test "x$VERSION_PRE" != "x$with_version_pre"; then
24432 24432 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
24433 24433 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
24434 24434 fi
24435 24435 fi
24436 24436 else
24437 24437 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24438 24438 # Default is to use "internal" as pre
24439 24439 VERSION_PRE="internal"
24440 24440 fi
24441 24441 fi
24442 24442
24443 24443
24444 24444 # Check whether --with-version-opt was given.
24445 24445 if test "${with_version_opt+set}" = set; then :
24446 24446 withval=$with_version_opt; with_version_opt_present=true
24447 24447 else
24448 24448 with_version_opt_present=false
24449 24449 fi
24450 24450
24451 24451
24452 24452 if test "x$with_version_opt_present" = xtrue; then
24453 24453 if test "x$with_version_opt" = xyes; then
24454 24454 as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
24455 24455 elif test "x$with_version_opt" = xno; then
24456 24456 # Interpret --without-* as empty string instead of the literal "no"
24457 24457 VERSION_OPT=
24458 24458 else
24459 24459 # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
24460 24460 VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
24461 24461 if test "x$VERSION_OPT" != "x$with_version_opt"; then
24462 24462 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
24463 24463 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
24464 24464 fi
24465 24465 fi
24466 24466 else
24467 24467 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24468 24468 # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
24469 24469 timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
24470 24470 # Outer [ ] to quote m4.
24471 24471 basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
24472 24472 VERSION_OPT="$timestamp.$USERNAME.$basedirname"
24473 24473 fi
24474 24474 fi
24475 24475
24476 24476
24477 24477 # Check whether --with-version-build was given.
24478 24478 if test "${with_version_build+set}" = set; then :
24479 24479 withval=$with_version_build; with_version_build_present=true
24480 24480 else
24481 24481 with_version_build_present=false
24482 24482 fi
24483 24483
24484 24484
24485 24485 if test "x$with_version_build_present" = xtrue; then
24486 24486 if test "x$with_version_build" = xyes; then
24487 24487 as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
24488 24488 elif test "x$with_version_build" = xno; then
24489 24489 # Interpret --without-* as empty string instead of the literal "no"
24490 24490 VERSION_BUILD=
24491 24491 elif test "x$with_version_build" = x; then
24492 24492 VERSION_BUILD=
24493 24493 else
24494 24494
24495 24495 # Additional [] needed to keep m4 from mangling shell constructs.
24496 24496 if ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
24497 24497 as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
24498 24498 fi
24499 24499 # Extract the version number without leading zeros.
24500 24500 cleaned_value=${BASH_REMATCH[1]}
24501 24501 if test "x$cleaned_value" = x; then
24502 24502 # Special case for zero
24503 24503 cleaned_value=${BASH_REMATCH[2]}
24504 24504 fi
24505 24505
24506 24506 if test $cleaned_value -gt 255; then
24507 24507 as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
24508 24508 fi
24509 24509 if test "x$cleaned_value" != "x$with_version_build"; then
24510 24510 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
24511 24511 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
24512 24512 fi
24513 24513 VERSION_BUILD=$cleaned_value
24514 24514
24515 24515 fi
24516 24516 else
24517 24517 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24518 24518 # Default is to not have a build number.
24519 24519 VERSION_BUILD=""
24520 24520 # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
24521 24521 VERSION_BUILD=0
24522 24522 fi
24523 24523 fi
24524 24524
24525 24525
24526 24526 # Check whether --with-version-major was given.
24527 24527 if test "${with_version_major+set}" = set; then :
24528 24528 withval=$with_version_major; with_version_major_present=true
24529 24529 else
24530 24530 with_version_major_present=false
24531 24531 fi
24532 24532
24533 24533
24534 24534 if test "x$with_version_major_present" = xtrue; then
24535 24535 if test "x$with_version_major" = xyes; then
24536 24536 as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
24537 24537 else
24538 24538
24539 24539 # Additional [] needed to keep m4 from mangling shell constructs.
24540 24540 if ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
24541 24541 as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
24542 24542 fi
24543 24543 # Extract the version number without leading zeros.
24544 24544 cleaned_value=${BASH_REMATCH[1]}
24545 24545 if test "x$cleaned_value" = x; then
24546 24546 # Special case for zero
24547 24547 cleaned_value=${BASH_REMATCH[2]}
24548 24548 fi
24549 24549
24550 24550 if test $cleaned_value -gt 255; then
24551 24551 as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
24552 24552 fi
24553 24553 if test "x$cleaned_value" != "x$with_version_major"; then
24554 24554 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
24555 24555 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
24556 24556 fi
24557 24557 VERSION_MAJOR=$cleaned_value
24558 24558
24559 24559 fi
24560 24560 else
24561 24561 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24562 24562 # Default is to get value from version-numbers
24563 24563 VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
24564 24564 fi
24565 24565 fi
24566 24566
24567 24567
24568 24568 # Check whether --with-version-minor was given.
24569 24569 if test "${with_version_minor+set}" = set; then :
24570 24570 withval=$with_version_minor; with_version_minor_present=true
24571 24571 else
24572 24572 with_version_minor_present=false
24573 24573 fi
24574 24574
24575 24575
24576 24576 if test "x$with_version_minor_present" = xtrue; then
24577 24577 if test "x$with_version_minor" = xyes; then
24578 24578 as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
24579 24579 elif test "x$with_version_minor" = xno; then
24580 24580 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24581 24581 VERSION_MINOR=0
24582 24582 elif test "x$with_version_minor" = x; then
24583 24583 VERSION_MINOR=0
24584 24584 else
24585 24585
24586 24586 # Additional [] needed to keep m4 from mangling shell constructs.
24587 24587 if ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
24588 24588 as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
24589 24589 fi
24590 24590 # Extract the version number without leading zeros.
24591 24591 cleaned_value=${BASH_REMATCH[1]}
24592 24592 if test "x$cleaned_value" = x; then
24593 24593 # Special case for zero
24594 24594 cleaned_value=${BASH_REMATCH[2]}
24595 24595 fi
24596 24596
24597 24597 if test $cleaned_value -gt 255; then
24598 24598 as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
24599 24599 fi
24600 24600 if test "x$cleaned_value" != "x$with_version_minor"; then
24601 24601 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
24602 24602 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
24603 24603 fi
24604 24604 VERSION_MINOR=$cleaned_value
24605 24605
24606 24606 fi
24607 24607 else
24608 24608 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24609 24609 # Default is 0, if unspecified
24610 24610 VERSION_MINOR=0
24611 24611 fi
24612 24612 fi
24613 24613
24614 24614
24615 24615 # Check whether --with-version-security was given.
24616 24616 if test "${with_version_security+set}" = set; then :
24617 24617 withval=$with_version_security; with_version_security_present=true
24618 24618 else
24619 24619 with_version_security_present=false
24620 24620 fi
24621 24621
24622 24622
24623 24623 if test "x$with_version_security_present" = xtrue; then
24624 24624 if test "x$with_version_security" = xyes; then
24625 24625 as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
24626 24626 elif test "x$with_version_security" = xno; then
24627 24627 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24628 24628 VERSION_SECURITY=0
24629 24629 elif test "x$with_version_security" = x; then
24630 24630 VERSION_SECURITY=0
24631 24631 else
24632 24632
24633 24633 # Additional [] needed to keep m4 from mangling shell constructs.
24634 24634 if ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
24635 24635 as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
24636 24636 fi
24637 24637 # Extract the version number without leading zeros.
24638 24638 cleaned_value=${BASH_REMATCH[1]}
24639 24639 if test "x$cleaned_value" = x; then
24640 24640 # Special case for zero
24641 24641 cleaned_value=${BASH_REMATCH[2]}
24642 24642 fi
24643 24643
24644 24644 if test $cleaned_value -gt 255; then
24645 24645 as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
24646 24646 fi
24647 24647 if test "x$cleaned_value" != "x$with_version_security"; then
24648 24648 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
24649 24649 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
24650 24650 fi
24651 24651 VERSION_SECURITY=$cleaned_value
24652 24652
24653 24653 fi
24654 24654 else
24655 24655 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24656 24656 # Default is 0, if unspecified
24657 24657 VERSION_SECURITY=0
24658 24658 fi
24659 24659 fi
24660 24660
24661 24661
24662 24662 # Check whether --with-version-patch was given.
24663 24663 if test "${with_version_patch+set}" = set; then :
24664 24664 withval=$with_version_patch; with_version_patch_present=true
24665 24665 else
24666 24666 with_version_patch_present=false
24667 24667 fi
24668 24668
24669 24669
24670 24670 if test "x$with_version_patch_present" = xtrue; then
24671 24671 if test "x$with_version_patch" = xyes; then
24672 24672 as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
24673 24673 elif test "x$with_version_patch" = xno; then
24674 24674 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24675 24675 VERSION_PATCH=0
24676 24676 elif test "x$with_version_patch" = x; then
24677 24677 VERSION_PATCH=0
24678 24678 else
24679 24679
24680 24680 # Additional [] needed to keep m4 from mangling shell constructs.
24681 24681 if ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
24682 24682 as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
24683 24683 fi
24684 24684 # Extract the version number without leading zeros.
24685 24685 cleaned_value=${BASH_REMATCH[1]}
24686 24686 if test "x$cleaned_value" = x; then
24687 24687 # Special case for zero
24688 24688 cleaned_value=${BASH_REMATCH[2]}
24689 24689 fi
24690 24690
24691 24691 if test $cleaned_value -gt 255; then
24692 24692 as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
24693 24693 fi
24694 24694 if test "x$cleaned_value" != "x$with_version_patch"; then
24695 24695 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
24696 24696 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
24697 24697 fi
24698 24698 VERSION_PATCH=$cleaned_value
24699 24699
24700 24700 fi
24701 24701 else
24702 24702 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24703 24703 # Default is 0, if unspecified
24704 24704 VERSION_PATCH=0
24705 24705 fi
24706 24706 fi
24707 24707
24708 24708 # Calculate derived version properties
24709 24709
24710 24710 # Set VERSION_IS_GA based on if VERSION_PRE has a value
24711 24711 if test "x$VERSION_PRE" = x; then
24712 24712 VERSION_IS_GA=true
24713 24713 else
24714 24714 VERSION_IS_GA=false
24715 24715 fi
24716 24716
24717 24717 # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
24718 24718 VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
24719 24719
24720 24720 stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
24721 24721 # Strip trailing zeroes from stripped_version_number
24722 24722 for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
24723 24723 VERSION_NUMBER=$stripped_version_number
24724 24724
24725 24725 # The complete version string, with additional build information
24726 24726 if test "x$VERSION_BUILD$VERSION_OPT" = x; then
24727 24727 VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24728 24728 else
24729 24729 # If either build or opt is set, we need a + separator
24730 24730 VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
24731 24731 fi
24732 24732
24733 24733 # The short version string, just VERSION_NUMBER and PRE, if present.
24734 24734 VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24735 24735
24736 24736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
24737 24737 $as_echo_n "checking for version string... " >&6; }
24738 24738 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
24739 24739 $as_echo "$VERSION_STRING" >&6; }
24740 24740
24741 24741
24742 24742
24743 24743
24744 24744
24745 24745
24746 24746
24747 24747
24748 24748
24749 24749
24750 24750
24751 24751
24752 24752
24753 24753
24754 24754
24755 24755 ###############################################################################
24756 24756 #
24757 24757 # Setup BootJDK, used to bootstrap the build.
24758 24758 #
24759 24759 ###############################################################################
24760 24760
24761 24761
24762 24762 BOOT_JDK_FOUND=no
24763 24763
24764 24764 # Check whether --with-boot-jdk was given.
24765 24765 if test "${with_boot_jdk+set}" = set; then :
24766 24766 withval=$with_boot_jdk;
24767 24767 fi
24768 24768
24769 24769
24770 24770 # We look for the Boot JDK through various means, going from more certain to
24771 24771 # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
24772 24772 # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
24773 24773 # must check if this is indeed valid; otherwise we'll continue looking.
24774 24774
24775 24775 # Test: Is bootjdk explicitely set by command line arguments?
24776 24776
24777 24777 if test "x$BOOT_JDK_FOUND" = xno; then
24778 24778 # Now execute the test
24779 24779
24780 24780 if test "x$with_boot_jdk" != x; then
24781 24781 BOOT_JDK=$with_boot_jdk
24782 24782 BOOT_JDK_FOUND=maybe
24783 24783 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
24784 24784 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
24785 24785 fi
24786 24786
24787 24787
24788 24788 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24789 24789 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24790 24790 # Do we have a bin/java?
24791 24791 if test ! -x "$BOOT_JDK/bin/java"; then
24792 24792 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24793 24793 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24794 24794 BOOT_JDK_FOUND=no
24795 24795 else
24796 24796 # Do we have a bin/javac?
24797 24797 if test ! -x "$BOOT_JDK/bin/javac"; then
24798 24798 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24799 24799 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24800 24800 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24801 24801 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24802 24802 BOOT_JDK_FOUND=no
24803 24803 else
24804 24804 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24805 24805 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
24806 24806
24807 24807 # Extra M4 quote needed to protect [] in grep expression.
24808 24808 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24809 24809 if test "x$FOUND_CORRECT_VERSION" = x; then
24810 24810 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24811 24811 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24812 24812 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24813 24813 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24814 24814 BOOT_JDK_FOUND=no
24815 24815 else
24816 24816 # We're done! :-)
24817 24817 BOOT_JDK_FOUND=yes
24818 24818
24819 24819 # Only process if variable expands to non-empty
24820 24820
24821 24821 if test "x$BOOT_JDK" != x; then
24822 24822 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24823 24823
24824 24824 # Input might be given as Windows format, start by converting to
24825 24825 # unix format.
24826 24826 path="$BOOT_JDK"
24827 24827 new_path=`$CYGPATH -u "$path"`
24828 24828
24829 24829 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24830 24830 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24831 24831 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24832 24832 # "foo.exe" is OK but "foo" is an error.
24833 24833 #
24834 24834 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24835 24835 # It is also a way to make sure we got the proper file name for the real test later on.
24836 24836 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24837 24837 if test "x$test_shortpath" = x; then
24838 24838 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24839 24839 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24840 24840 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24841 24841 fi
24842 24842
24843 24843 # Call helper function which possibly converts this using DOS-style short mode.
24844 24844 # If so, the updated path is stored in $new_path.
24845 24845
24846 24846 input_path="$new_path"
24847 24847 # Check if we need to convert this using DOS-style short mode. If the path
24848 24848 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24849 24849 # take no chances and rewrite it.
24850 24850 # Note: m4 eats our [], so we need to use [ and ] instead.
24851 24851 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24852 24852 if test "x$has_forbidden_chars" != x; then
24853 24853 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24854 24854 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24855 24855 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24856 24856 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24857 24857 # Going to short mode and back again did indeed matter. Since short mode is
24858 24858 # case insensitive, let's make it lowercase to improve readability.
24859 24859 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24860 24860 # Now convert it back to Unix-style (cygpath)
24861 24861 input_path=`$CYGPATH -u "$shortmode_path"`
24862 24862 new_path="$input_path"
24863 24863 fi
24864 24864 fi
24865 24865
24866 24866 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24867 24867 if test "x$test_cygdrive_prefix" = x; then
24868 24868 # As a simple fix, exclude /usr/bin since it's not a real path.
24869 24869 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24870 24870 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24871 24871 # a path prefixed by /cygdrive for fixpath to work.
24872 24872 new_path="$CYGWIN_ROOT_PATH$input_path"
24873 24873 fi
24874 24874 fi
24875 24875
24876 24876
24877 24877 if test "x$path" != "x$new_path"; then
24878 24878 BOOT_JDK="$new_path"
24879 24879 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24880 24880 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24881 24881 fi
24882 24882
24883 24883 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24884 24884
24885 24885 path="$BOOT_JDK"
24886 24886 has_colon=`$ECHO $path | $GREP ^.:`
24887 24887 new_path="$path"
24888 24888 if test "x$has_colon" = x; then
24889 24889 # Not in mixed or Windows style, start by that.
24890 24890 new_path=`cmd //c echo $path`
24891 24891 fi
24892 24892
24893 24893
24894 24894 input_path="$new_path"
24895 24895 # Check if we need to convert this using DOS-style short mode. If the path
24896 24896 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24897 24897 # take no chances and rewrite it.
24898 24898 # Note: m4 eats our [], so we need to use [ and ] instead.
24899 24899 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24900 24900 if test "x$has_forbidden_chars" != x; then
24901 24901 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24902 24902 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24903 24903 fi
24904 24904
24905 24905
24906 24906 windows_path="$new_path"
24907 24907 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24908 24908 unix_path=`$CYGPATH -u "$windows_path"`
24909 24909 new_path="$unix_path"
24910 24910 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24911 24911 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24912 24912 new_path="$unix_path"
24913 24913 fi
24914 24914
24915 24915 if test "x$path" != "x$new_path"; then
24916 24916 BOOT_JDK="$new_path"
24917 24917 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24918 24918 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24919 24919 fi
24920 24920
24921 24921 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24922 24922 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24923 24923
24924 24924 else
24925 24925 # We're on a unix platform. Hooray! :)
24926 24926 path="$BOOT_JDK"
24927 24927 has_space=`$ECHO "$path" | $GREP " "`
24928 24928 if test "x$has_space" != x; then
24929 24929 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24930 24930 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24931 24931 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24932 24932 fi
24933 24933
24934 24934 # Use eval to expand a potential ~
24935 24935 eval path="$path"
24936 24936 if test ! -f "$path" && test ! -d "$path"; then
24937 24937 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24938 24938 fi
24939 24939
24940 24940 if test -d "$path"; then
24941 24941 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24942 24942 else
24943 24943 dir="`$DIRNAME "$path"`"
24944 24944 base="`$BASENAME "$path"`"
24945 24945 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24946 24946 fi
24947 24947 fi
24948 24948 fi
24949 24949
24950 24950 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24951 24951 $as_echo_n "checking for Boot JDK... " >&6; }
24952 24952 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24953 24953 $as_echo "$BOOT_JDK" >&6; }
24954 24954 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24955 24955 $as_echo_n "checking Boot JDK version... " >&6; }
24956 24956 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24957 24957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24958 24958 $as_echo "$BOOT_JDK_VERSION" >&6; }
24959 24959 fi # end check jdk version
24960 24960 fi # end check javac
24961 24961 fi # end check java
24962 24962 fi # end check boot jdk found
24963 24963 fi
24964 24964
24965 24965 if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
24966 24966 # Having specified an argument which is incorrect will produce an instant failure;
24967 24967 # we should not go on looking
24968 24968 as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
24969 24969 fi
24970 24970
24971 24971 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
24972 24972
24973 24973 if test "x$BOOT_JDK_FOUND" = xno; then
24974 24974 # Now execute the test
24975 24975
24976 24976 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
24977 24977 # First check at user selected default
24978 24978
24979 24979 if test "x$BOOT_JDK_FOUND" = xno; then
24980 24980 # Now execute the test
24981 24981
24982 24982 if test -x /usr/libexec/java_home; then
24983 24983 BOOT_JDK=`/usr/libexec/java_home `
24984 24984 BOOT_JDK_FOUND=maybe
24985 24985 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
24986 24986 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
24987 24987 fi
24988 24988
24989 24989
24990 24990 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24991 24991 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24992 24992 # Do we have a bin/java?
24993 24993 if test ! -x "$BOOT_JDK/bin/java"; then
24994 24994 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24995 24995 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24996 24996 BOOT_JDK_FOUND=no
24997 24997 else
24998 24998 # Do we have a bin/javac?
24999 24999 if test ! -x "$BOOT_JDK/bin/javac"; then
25000 25000 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25001 25001 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25002 25002 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25003 25003 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25004 25004 BOOT_JDK_FOUND=no
25005 25005 else
25006 25006 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25007 25007 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25008 25008
25009 25009 # Extra M4 quote needed to protect [] in grep expression.
25010 25010 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25011 25011 if test "x$FOUND_CORRECT_VERSION" = x; then
25012 25012 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25013 25013 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25014 25014 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25015 25015 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25016 25016 BOOT_JDK_FOUND=no
25017 25017 else
25018 25018 # We're done! :-)
25019 25019 BOOT_JDK_FOUND=yes
25020 25020
25021 25021 # Only process if variable expands to non-empty
25022 25022
25023 25023 if test "x$BOOT_JDK" != x; then
25024 25024 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25025 25025
25026 25026 # Input might be given as Windows format, start by converting to
25027 25027 # unix format.
25028 25028 path="$BOOT_JDK"
25029 25029 new_path=`$CYGPATH -u "$path"`
25030 25030
25031 25031 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25032 25032 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25033 25033 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25034 25034 # "foo.exe" is OK but "foo" is an error.
25035 25035 #
25036 25036 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25037 25037 # It is also a way to make sure we got the proper file name for the real test later on.
25038 25038 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25039 25039 if test "x$test_shortpath" = x; then
25040 25040 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25041 25041 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25042 25042 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25043 25043 fi
25044 25044
25045 25045 # Call helper function which possibly converts this using DOS-style short mode.
25046 25046 # If so, the updated path is stored in $new_path.
25047 25047
25048 25048 input_path="$new_path"
25049 25049 # Check if we need to convert this using DOS-style short mode. If the path
25050 25050 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25051 25051 # take no chances and rewrite it.
25052 25052 # Note: m4 eats our [], so we need to use [ and ] instead.
25053 25053 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25054 25054 if test "x$has_forbidden_chars" != x; then
25055 25055 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25056 25056 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25057 25057 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25058 25058 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25059 25059 # Going to short mode and back again did indeed matter. Since short mode is
25060 25060 # case insensitive, let's make it lowercase to improve readability.
25061 25061 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25062 25062 # Now convert it back to Unix-style (cygpath)
25063 25063 input_path=`$CYGPATH -u "$shortmode_path"`
25064 25064 new_path="$input_path"
25065 25065 fi
25066 25066 fi
25067 25067
25068 25068 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25069 25069 if test "x$test_cygdrive_prefix" = x; then
25070 25070 # As a simple fix, exclude /usr/bin since it's not a real path.
25071 25071 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25072 25072 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25073 25073 # a path prefixed by /cygdrive for fixpath to work.
25074 25074 new_path="$CYGWIN_ROOT_PATH$input_path"
25075 25075 fi
25076 25076 fi
25077 25077
25078 25078
25079 25079 if test "x$path" != "x$new_path"; then
25080 25080 BOOT_JDK="$new_path"
25081 25081 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25082 25082 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25083 25083 fi
25084 25084
25085 25085 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25086 25086
25087 25087 path="$BOOT_JDK"
25088 25088 has_colon=`$ECHO $path | $GREP ^.:`
25089 25089 new_path="$path"
25090 25090 if test "x$has_colon" = x; then
25091 25091 # Not in mixed or Windows style, start by that.
25092 25092 new_path=`cmd //c echo $path`
25093 25093 fi
25094 25094
25095 25095
25096 25096 input_path="$new_path"
25097 25097 # Check if we need to convert this using DOS-style short mode. If the path
25098 25098 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25099 25099 # take no chances and rewrite it.
25100 25100 # Note: m4 eats our [], so we need to use [ and ] instead.
25101 25101 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25102 25102 if test "x$has_forbidden_chars" != x; then
25103 25103 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25104 25104 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25105 25105 fi
25106 25106
25107 25107
25108 25108 windows_path="$new_path"
25109 25109 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25110 25110 unix_path=`$CYGPATH -u "$windows_path"`
25111 25111 new_path="$unix_path"
25112 25112 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25113 25113 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25114 25114 new_path="$unix_path"
25115 25115 fi
25116 25116
25117 25117 if test "x$path" != "x$new_path"; then
25118 25118 BOOT_JDK="$new_path"
25119 25119 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25120 25120 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25121 25121 fi
25122 25122
25123 25123 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25124 25124 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25125 25125
25126 25126 else
25127 25127 # We're on a unix platform. Hooray! :)
25128 25128 path="$BOOT_JDK"
25129 25129 has_space=`$ECHO "$path" | $GREP " "`
25130 25130 if test "x$has_space" != x; then
25131 25131 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25132 25132 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25133 25133 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25134 25134 fi
25135 25135
25136 25136 # Use eval to expand a potential ~
25137 25137 eval path="$path"
25138 25138 if test ! -f "$path" && test ! -d "$path"; then
25139 25139 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25140 25140 fi
25141 25141
25142 25142 if test -d "$path"; then
25143 25143 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25144 25144 else
25145 25145 dir="`$DIRNAME "$path"`"
25146 25146 base="`$BASENAME "$path"`"
25147 25147 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25148 25148 fi
25149 25149 fi
25150 25150 fi
25151 25151
25152 25152 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25153 25153 $as_echo_n "checking for Boot JDK... " >&6; }
25154 25154 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25155 25155 $as_echo "$BOOT_JDK" >&6; }
25156 25156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25157 25157 $as_echo_n "checking Boot JDK version... " >&6; }
25158 25158 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
25159 25159 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25160 25160 $as_echo "$BOOT_JDK_VERSION" >&6; }
25161 25161 fi # end check jdk version
25162 25162 fi # end check javac
25163 25163 fi # end check java
25164 25164 fi # end check boot jdk found
25165 25165 fi
25166 25166
25167 25167 # If that did not work out (e.g. too old), try explicit versions instead
25168 25168
25169 25169 if test "x$BOOT_JDK_FOUND" = xno; then
25170 25170 # Now execute the test
25171 25171
25172 25172 if test -x /usr/libexec/java_home; then
25173 25173 BOOT_JDK=`/usr/libexec/java_home -v 1.9`
25174 25174 BOOT_JDK_FOUND=maybe
25175 25175 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
25176 25176 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
25177 25177 fi
25178 25178
25179 25179
25180 25180 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25181 25181 if test "x$BOOT_JDK_FOUND" = xmaybe; then
25182 25182 # Do we have a bin/java?
25183 25183 if test ! -x "$BOOT_JDK/bin/java"; then
25184 25184 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25185 25185 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25186 25186 BOOT_JDK_FOUND=no
25187 25187 else
25188 25188 # Do we have a bin/javac?
25189 25189 if test ! -x "$BOOT_JDK/bin/javac"; then
25190 25190 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25191 25191 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25192 25192 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25193 25193 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25194 25194 BOOT_JDK_FOUND=no
25195 25195 else
25196 25196 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25197 25197 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25198 25198
25199 25199 # Extra M4 quote needed to protect [] in grep expression.
25200 25200 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25201 25201 if test "x$FOUND_CORRECT_VERSION" = x; then
25202 25202 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25203 25203 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25204 25204 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25205 25205 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25206 25206 BOOT_JDK_FOUND=no
25207 25207 else
25208 25208 # We're done! :-)
25209 25209 BOOT_JDK_FOUND=yes
25210 25210
25211 25211 # Only process if variable expands to non-empty
25212 25212
25213 25213 if test "x$BOOT_JDK" != x; then
25214 25214 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25215 25215
25216 25216 # Input might be given as Windows format, start by converting to
25217 25217 # unix format.
25218 25218 path="$BOOT_JDK"
25219 25219 new_path=`$CYGPATH -u "$path"`
25220 25220
25221 25221 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25222 25222 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25223 25223 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25224 25224 # "foo.exe" is OK but "foo" is an error.
25225 25225 #
25226 25226 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25227 25227 # It is also a way to make sure we got the proper file name for the real test later on.
25228 25228 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25229 25229 if test "x$test_shortpath" = x; then
25230 25230 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25231 25231 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25232 25232 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25233 25233 fi
25234 25234
25235 25235 # Call helper function which possibly converts this using DOS-style short mode.
25236 25236 # If so, the updated path is stored in $new_path.
25237 25237
25238 25238 input_path="$new_path"
25239 25239 # Check if we need to convert this using DOS-style short mode. If the path
25240 25240 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25241 25241 # take no chances and rewrite it.
25242 25242 # Note: m4 eats our [], so we need to use [ and ] instead.
25243 25243 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25244 25244 if test "x$has_forbidden_chars" != x; then
25245 25245 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25246 25246 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25247 25247 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25248 25248 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25249 25249 # Going to short mode and back again did indeed matter. Since short mode is
25250 25250 # case insensitive, let's make it lowercase to improve readability.
25251 25251 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25252 25252 # Now convert it back to Unix-style (cygpath)
25253 25253 input_path=`$CYGPATH -u "$shortmode_path"`
25254 25254 new_path="$input_path"
25255 25255 fi
25256 25256 fi
25257 25257
25258 25258 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25259 25259 if test "x$test_cygdrive_prefix" = x; then
25260 25260 # As a simple fix, exclude /usr/bin since it's not a real path.
25261 25261 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25262 25262 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25263 25263 # a path prefixed by /cygdrive for fixpath to work.
25264 25264 new_path="$CYGWIN_ROOT_PATH$input_path"
25265 25265 fi
25266 25266 fi
25267 25267
25268 25268
25269 25269 if test "x$path" != "x$new_path"; then
25270 25270 BOOT_JDK="$new_path"
25271 25271 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25272 25272 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25273 25273 fi
25274 25274
25275 25275 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25276 25276
25277 25277 path="$BOOT_JDK"
25278 25278 has_colon=`$ECHO $path | $GREP ^.:`
25279 25279 new_path="$path"
25280 25280 if test "x$has_colon" = x; then
25281 25281 # Not in mixed or Windows style, start by that.
25282 25282 new_path=`cmd //c echo $path`
25283 25283 fi
25284 25284
25285 25285
25286 25286 input_path="$new_path"
25287 25287 # Check if we need to convert this using DOS-style short mode. If the path
25288 25288 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25289 25289 # take no chances and rewrite it.
25290 25290 # Note: m4 eats our [], so we need to use [ and ] instead.
25291 25291 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25292 25292 if test "x$has_forbidden_chars" != x; then
25293 25293 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25294 25294 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25295 25295 fi
25296 25296
25297 25297
25298 25298 windows_path="$new_path"
25299 25299 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25300 25300 unix_path=`$CYGPATH -u "$windows_path"`
25301 25301 new_path="$unix_path"
25302 25302 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25303 25303 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25304 25304 new_path="$unix_path"
25305 25305 fi
25306 25306
25307 25307 if test "x$path" != "x$new_path"; then
25308 25308 BOOT_JDK="$new_path"
25309 25309 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25310 25310 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25311 25311 fi
25312 25312
25313 25313 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25314 25314 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25315 25315
25316 25316 else
25317 25317 # We're on a unix platform. Hooray! :)
25318 25318 path="$BOOT_JDK"
25319 25319 has_space=`$ECHO "$path" | $GREP " "`
25320 25320 if test "x$has_space" != x; then
25321 25321 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25322 25322 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25323 25323 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25324 25324 fi
25325 25325
25326 25326 # Use eval to expand a potential ~
25327 25327 eval path="$path"
25328 25328 if test ! -f "$path" && test ! -d "$path"; then
25329 25329 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25330 25330 fi
25331 25331
25332 25332 if test -d "$path"; then
25333 25333 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25334 25334 else
25335 25335 dir="`$DIRNAME "$path"`"
25336 25336 base="`$BASENAME "$path"`"
25337 25337 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25338 25338 fi
25339 25339 fi
25340 25340 fi
25341 25341
25342 25342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25343 25343 $as_echo_n "checking for Boot JDK... " >&6; }
25344 25344 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25345 25345 $as_echo "$BOOT_JDK" >&6; }
25346 25346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25347 25347 $as_echo_n "checking Boot JDK version... " >&6; }
25348 25348 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
25349 25349 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25350 25350 $as_echo "$BOOT_JDK_VERSION" >&6; }
25351 25351 fi # end check jdk version
25352 25352 fi # end check javac
25353 25353 fi # end check java
25354 25354 fi # end check boot jdk found
25355 25355 fi
25356 25356
25357 25357
25358 25358 if test "x$BOOT_JDK_FOUND" = xno; then
25359 25359 # Now execute the test
25360 25360
25361 25361 if test -x /usr/libexec/java_home; then
25362 25362 BOOT_JDK=`/usr/libexec/java_home -v 1.8`
25363 25363 BOOT_JDK_FOUND=maybe
25364 25364 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
25365 25365 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
25366 25366 fi
25367 25367
25368 25368
25369 25369 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25370 25370 if test "x$BOOT_JDK_FOUND" = xmaybe; then
25371 25371 # Do we have a bin/java?
25372 25372 if test ! -x "$BOOT_JDK/bin/java"; then
25373 25373 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25374 25374 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25375 25375 BOOT_JDK_FOUND=no
25376 25376 else
25377 25377 # Do we have a bin/javac?
25378 25378 if test ! -x "$BOOT_JDK/bin/javac"; then
25379 25379 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25380 25380 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25381 25381 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25382 25382 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25383 25383 BOOT_JDK_FOUND=no
25384 25384 else
25385 25385 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25386 25386 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25387 25387
25388 25388 # Extra M4 quote needed to protect [] in grep expression.
25389 25389 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25390 25390 if test "x$FOUND_CORRECT_VERSION" = x; then
25391 25391 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25392 25392 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25393 25393 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25394 25394 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25395 25395 BOOT_JDK_FOUND=no
25396 25396 else
25397 25397 # We're done! :-)
25398 25398 BOOT_JDK_FOUND=yes
25399 25399
25400 25400 # Only process if variable expands to non-empty
25401 25401
25402 25402 if test "x$BOOT_JDK" != x; then
25403 25403 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25404 25404
25405 25405 # Input might be given as Windows format, start by converting to
25406 25406 # unix format.
25407 25407 path="$BOOT_JDK"
25408 25408 new_path=`$CYGPATH -u "$path"`
25409 25409
25410 25410 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25411 25411 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25412 25412 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25413 25413 # "foo.exe" is OK but "foo" is an error.
25414 25414 #
25415 25415 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25416 25416 # It is also a way to make sure we got the proper file name for the real test later on.
25417 25417 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25418 25418 if test "x$test_shortpath" = x; then
25419 25419 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25420 25420 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25421 25421 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25422 25422 fi
25423 25423
25424 25424 # Call helper function which possibly converts this using DOS-style short mode.
25425 25425 # If so, the updated path is stored in $new_path.
25426 25426
25427 25427 input_path="$new_path"
25428 25428 # Check if we need to convert this using DOS-style short mode. If the path
25429 25429 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25430 25430 # take no chances and rewrite it.
25431 25431 # Note: m4 eats our [], so we need to use [ and ] instead.
25432 25432 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25433 25433 if test "x$has_forbidden_chars" != x; then
25434 25434 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25435 25435 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25436 25436 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25437 25437 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25438 25438 # Going to short mode and back again did indeed matter. Since short mode is
25439 25439 # case insensitive, let's make it lowercase to improve readability.
25440 25440 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25441 25441 # Now convert it back to Unix-style (cygpath)
25442 25442 input_path=`$CYGPATH -u "$shortmode_path"`
25443 25443 new_path="$input_path"
25444 25444 fi
25445 25445 fi
25446 25446
25447 25447 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25448 25448 if test "x$test_cygdrive_prefix" = x; then
25449 25449 # As a simple fix, exclude /usr/bin since it's not a real path.
25450 25450 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25451 25451 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25452 25452 # a path prefixed by /cygdrive for fixpath to work.
25453 25453 new_path="$CYGWIN_ROOT_PATH$input_path"
25454 25454 fi
25455 25455 fi
25456 25456
25457 25457
25458 25458 if test "x$path" != "x$new_path"; then
25459 25459 BOOT_JDK="$new_path"
25460 25460 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25461 25461 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25462 25462 fi
25463 25463
25464 25464 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25465 25465
25466 25466 path="$BOOT_JDK"
25467 25467 has_colon=`$ECHO $path | $GREP ^.:`
25468 25468 new_path="$path"
25469 25469 if test "x$has_colon" = x; then
25470 25470 # Not in mixed or Windows style, start by that.
25471 25471 new_path=`cmd //c echo $path`
25472 25472 fi
25473 25473
25474 25474
25475 25475 input_path="$new_path"
25476 25476 # Check if we need to convert this using DOS-style short mode. If the path
25477 25477 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25478 25478 # take no chances and rewrite it.
25479 25479 # Note: m4 eats our [], so we need to use [ and ] instead.
25480 25480 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25481 25481 if test "x$has_forbidden_chars" != x; then
25482 25482 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25483 25483 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25484 25484 fi
25485 25485
25486 25486
25487 25487 windows_path="$new_path"
25488 25488 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25489 25489 unix_path=`$CYGPATH -u "$windows_path"`
25490 25490 new_path="$unix_path"
25491 25491 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25492 25492 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25493 25493 new_path="$unix_path"
25494 25494 fi
25495 25495
25496 25496 if test "x$path" != "x$new_path"; then
25497 25497 BOOT_JDK="$new_path"
25498 25498 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25499 25499 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25500 25500 fi
25501 25501
25502 25502 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25503 25503 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25504 25504
25505 25505 else
25506 25506 # We're on a unix platform. Hooray! :)
25507 25507 path="$BOOT_JDK"
25508 25508 has_space=`$ECHO "$path" | $GREP " "`
25509 25509 if test "x$has_space" != x; then
25510 25510 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25511 25511 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25512 25512 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25513 25513 fi
25514 25514
25515 25515 # Use eval to expand a potential ~
25516 25516 eval path="$path"
25517 25517 if test ! -f "$path" && test ! -d "$path"; then
25518 25518 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25519 25519 fi
25520 25520
25521 25521 if test -d "$path"; then
25522 25522 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25523 25523 else
25524 25524 dir="`$DIRNAME "$path"`"
25525 25525 base="`$BASENAME "$path"`"
25526 25526 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25527 25527 fi
25528 25528 fi
25529 25529 fi
25530 25530
25531 25531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25532 25532 $as_echo_n "checking for Boot JDK... " >&6; }
25533 25533 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25534 25534 $as_echo "$BOOT_JDK" >&6; }
25535 25535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25536 25536 $as_echo_n "checking Boot JDK version... " >&6; }
25537 25537 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
25538 25538 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25539 25539 $as_echo "$BOOT_JDK_VERSION" >&6; }
25540 25540 fi # end check jdk version
25541 25541 fi # end check javac
25542 25542 fi # end check java
25543 25543 fi # end check boot jdk found
25544 25544 fi
25545 25545
25546 25546
25547 25547 if test "x$BOOT_JDK_FOUND" = xno; then
25548 25548 # Now execute the test
25549 25549
25550 25550 if test -x /usr/libexec/java_home; then
25551 25551 BOOT_JDK=`/usr/libexec/java_home -v 1.7`
25552 25552 BOOT_JDK_FOUND=maybe
25553 25553 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
25554 25554 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
25555 25555 fi
25556 25556
25557 25557
25558 25558 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25559 25559 if test "x$BOOT_JDK_FOUND" = xmaybe; then
25560 25560 # Do we have a bin/java?
25561 25561 if test ! -x "$BOOT_JDK/bin/java"; then
25562 25562 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25563 25563 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25564 25564 BOOT_JDK_FOUND=no
25565 25565 else
25566 25566 # Do we have a bin/javac?
25567 25567 if test ! -x "$BOOT_JDK/bin/javac"; then
25568 25568 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25569 25569 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25570 25570 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25571 25571 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25572 25572 BOOT_JDK_FOUND=no
25573 25573 else
25574 25574 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25575 25575 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25576 25576
25577 25577 # Extra M4 quote needed to protect [] in grep expression.
25578 25578 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25579 25579 if test "x$FOUND_CORRECT_VERSION" = x; then
25580 25580 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25581 25581 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25582 25582 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25583 25583 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25584 25584 BOOT_JDK_FOUND=no
25585 25585 else
25586 25586 # We're done! :-)
25587 25587 BOOT_JDK_FOUND=yes
25588 25588
25589 25589 # Only process if variable expands to non-empty
25590 25590
25591 25591 if test "x$BOOT_JDK" != x; then
25592 25592 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25593 25593
25594 25594 # Input might be given as Windows format, start by converting to
25595 25595 # unix format.
25596 25596 path="$BOOT_JDK"
25597 25597 new_path=`$CYGPATH -u "$path"`
25598 25598
25599 25599 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25600 25600 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25601 25601 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25602 25602 # "foo.exe" is OK but "foo" is an error.
25603 25603 #
25604 25604 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25605 25605 # It is also a way to make sure we got the proper file name for the real test later on.
25606 25606 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25607 25607 if test "x$test_shortpath" = x; then
25608 25608 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25609 25609 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25610 25610 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25611 25611 fi
25612 25612
25613 25613 # Call helper function which possibly converts this using DOS-style short mode.
25614 25614 # If so, the updated path is stored in $new_path.
25615 25615
25616 25616 input_path="$new_path"
25617 25617 # Check if we need to convert this using DOS-style short mode. If the path
25618 25618 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25619 25619 # take no chances and rewrite it.
25620 25620 # Note: m4 eats our [], so we need to use [ and ] instead.
25621 25621 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25622 25622 if test "x$has_forbidden_chars" != x; then
25623 25623 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25624 25624 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25625 25625 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25626 25626 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25627 25627 # Going to short mode and back again did indeed matter. Since short mode is
25628 25628 # case insensitive, let's make it lowercase to improve readability.
25629 25629 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25630 25630 # Now convert it back to Unix-style (cygpath)
25631 25631 input_path=`$CYGPATH -u "$shortmode_path"`
25632 25632 new_path="$input_path"
25633 25633 fi
25634 25634 fi
25635 25635
25636 25636 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25637 25637 if test "x$test_cygdrive_prefix" = x; then
25638 25638 # As a simple fix, exclude /usr/bin since it's not a real path.
25639 25639 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25640 25640 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25641 25641 # a path prefixed by /cygdrive for fixpath to work.
25642 25642 new_path="$CYGWIN_ROOT_PATH$input_path"
25643 25643 fi
25644 25644 fi
25645 25645
25646 25646
25647 25647 if test "x$path" != "x$new_path"; then
25648 25648 BOOT_JDK="$new_path"
25649 25649 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25650 25650 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25651 25651 fi
25652 25652
25653 25653 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25654 25654
25655 25655 path="$BOOT_JDK"
25656 25656 has_colon=`$ECHO $path | $GREP ^.:`
25657 25657 new_path="$path"
25658 25658 if test "x$has_colon" = x; then
25659 25659 # Not in mixed or Windows style, start by that.
25660 25660 new_path=`cmd //c echo $path`
25661 25661 fi
25662 25662
25663 25663
25664 25664 input_path="$new_path"
25665 25665 # Check if we need to convert this using DOS-style short mode. If the path
25666 25666 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25667 25667 # take no chances and rewrite it.
25668 25668 # Note: m4 eats our [], so we need to use [ and ] instead.
25669 25669 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25670 25670 if test "x$has_forbidden_chars" != x; then
25671 25671 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25672 25672 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25673 25673 fi
25674 25674
25675 25675
25676 25676 windows_path="$new_path"
25677 25677 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25678 25678 unix_path=`$CYGPATH -u "$windows_path"`
25679 25679 new_path="$unix_path"
25680 25680 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25681 25681 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25682 25682 new_path="$unix_path"
25683 25683 fi
25684 25684
25685 25685 if test "x$path" != "x$new_path"; then
25686 25686 BOOT_JDK="$new_path"
25687 25687 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25688 25688 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25689 25689 fi
25690 25690
25691 25691 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25692 25692 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25693 25693
25694 25694 else
25695 25695 # We're on a unix platform. Hooray! :)
25696 25696 path="$BOOT_JDK"
25697 25697 has_space=`$ECHO "$path" | $GREP " "`
25698 25698 if test "x$has_space" != x; then
25699 25699 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25700 25700 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25701 25701 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25702 25702 fi
25703 25703
25704 25704 # Use eval to expand a potential ~
25705 25705 eval path="$path"
25706 25706 if test ! -f "$path" && test ! -d "$path"; then
25707 25707 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25708 25708 fi
25709 25709
25710 25710 if test -d "$path"; then
25711 25711 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25712 25712 else
25713 25713 dir="`$DIRNAME "$path"`"
25714 25714 base="`$BASENAME "$path"`"
25715 25715 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25716 25716 fi
25717 25717 fi
25718 25718 fi
25719 25719
25720 25720 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25721 25721 $as_echo_n "checking for Boot JDK... " >&6; }
25722 25722 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25723 25723 $as_echo "$BOOT_JDK" >&6; }
25724 25724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25725 25725 $as_echo_n "checking Boot JDK version... " >&6; }
25726 25726 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
25727 25727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25728 25728 $as_echo "$BOOT_JDK_VERSION" >&6; }
25729 25729 fi # end check jdk version
25730 25730 fi # end check javac
25731 25731 fi # end check java
25732 25732 fi # end check boot jdk found
25733 25733 fi
25734 25734
25735 25735 fi
25736 25736
25737 25737
25738 25738 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25739 25739 if test "x$BOOT_JDK_FOUND" = xmaybe; then
25740 25740 # Do we have a bin/java?
25741 25741 if test ! -x "$BOOT_JDK/bin/java"; then
25742 25742 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25743 25743 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25744 25744 BOOT_JDK_FOUND=no
25745 25745 else
25746 25746 # Do we have a bin/javac?
25747 25747 if test ! -x "$BOOT_JDK/bin/javac"; then
25748 25748 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25749 25749 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25750 25750 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25751 25751 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25752 25752 BOOT_JDK_FOUND=no
25753 25753 else
25754 25754 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25755 25755 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25756 25756
25757 25757 # Extra M4 quote needed to protect [] in grep expression.
25758 25758 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25759 25759 if test "x$FOUND_CORRECT_VERSION" = x; then
25760 25760 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25761 25761 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25762 25762 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25763 25763 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25764 25764 BOOT_JDK_FOUND=no
25765 25765 else
25766 25766 # We're done! :-)
25767 25767 BOOT_JDK_FOUND=yes
25768 25768
25769 25769 # Only process if variable expands to non-empty
25770 25770
25771 25771 if test "x$BOOT_JDK" != x; then
25772 25772 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25773 25773
25774 25774 # Input might be given as Windows format, start by converting to
25775 25775 # unix format.
25776 25776 path="$BOOT_JDK"
25777 25777 new_path=`$CYGPATH -u "$path"`
25778 25778
25779 25779 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25780 25780 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25781 25781 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25782 25782 # "foo.exe" is OK but "foo" is an error.
25783 25783 #
25784 25784 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25785 25785 # It is also a way to make sure we got the proper file name for the real test later on.
25786 25786 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25787 25787 if test "x$test_shortpath" = x; then
25788 25788 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25789 25789 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25790 25790 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25791 25791 fi
25792 25792
25793 25793 # Call helper function which possibly converts this using DOS-style short mode.
25794 25794 # If so, the updated path is stored in $new_path.
25795 25795
25796 25796 input_path="$new_path"
25797 25797 # Check if we need to convert this using DOS-style short mode. If the path
25798 25798 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25799 25799 # take no chances and rewrite it.
25800 25800 # Note: m4 eats our [], so we need to use [ and ] instead.
25801 25801 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25802 25802 if test "x$has_forbidden_chars" != x; then
25803 25803 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25804 25804 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25805 25805 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25806 25806 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25807 25807 # Going to short mode and back again did indeed matter. Since short mode is
25808 25808 # case insensitive, let's make it lowercase to improve readability.
25809 25809 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25810 25810 # Now convert it back to Unix-style (cygpath)
25811 25811 input_path=`$CYGPATH -u "$shortmode_path"`
25812 25812 new_path="$input_path"
25813 25813 fi
25814 25814 fi
25815 25815
25816 25816 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25817 25817 if test "x$test_cygdrive_prefix" = x; then
25818 25818 # As a simple fix, exclude /usr/bin since it's not a real path.
25819 25819 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25820 25820 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25821 25821 # a path prefixed by /cygdrive for fixpath to work.
25822 25822 new_path="$CYGWIN_ROOT_PATH$input_path"
25823 25823 fi
25824 25824 fi
25825 25825
25826 25826
25827 25827 if test "x$path" != "x$new_path"; then
25828 25828 BOOT_JDK="$new_path"
25829 25829 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25830 25830 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25831 25831 fi
25832 25832
25833 25833 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25834 25834
25835 25835 path="$BOOT_JDK"
25836 25836 has_colon=`$ECHO $path | $GREP ^.:`
25837 25837 new_path="$path"
25838 25838 if test "x$has_colon" = x; then
25839 25839 # Not in mixed or Windows style, start by that.
25840 25840 new_path=`cmd //c echo $path`
25841 25841 fi
25842 25842
25843 25843
25844 25844 input_path="$new_path"
25845 25845 # Check if we need to convert this using DOS-style short mode. If the path
25846 25846 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25847 25847 # take no chances and rewrite it.
25848 25848 # Note: m4 eats our [], so we need to use [ and ] instead.
25849 25849 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25850 25850 if test "x$has_forbidden_chars" != x; then
25851 25851 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25852 25852 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25853 25853 fi
25854 25854
25855 25855
25856 25856 windows_path="$new_path"
25857 25857 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25858 25858 unix_path=`$CYGPATH -u "$windows_path"`
25859 25859 new_path="$unix_path"
25860 25860 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25861 25861 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25862 25862 new_path="$unix_path"
25863 25863 fi
25864 25864
25865 25865 if test "x$path" != "x$new_path"; then
25866 25866 BOOT_JDK="$new_path"
25867 25867 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25868 25868 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25869 25869 fi
25870 25870
25871 25871 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25872 25872 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25873 25873
25874 25874 else
25875 25875 # We're on a unix platform. Hooray! :)
25876 25876 path="$BOOT_JDK"
25877 25877 has_space=`$ECHO "$path" | $GREP " "`
25878 25878 if test "x$has_space" != x; then
25879 25879 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25880 25880 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25881 25881 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25882 25882 fi
25883 25883
25884 25884 # Use eval to expand a potential ~
25885 25885 eval path="$path"
25886 25886 if test ! -f "$path" && test ! -d "$path"; then
25887 25887 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25888 25888 fi
25889 25889
25890 25890 if test -d "$path"; then
25891 25891 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25892 25892 else
25893 25893 dir="`$DIRNAME "$path"`"
25894 25894 base="`$BASENAME "$path"`"
25895 25895 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25896 25896 fi
25897 25897 fi
25898 25898 fi
25899 25899
25900 25900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25901 25901 $as_echo_n "checking for Boot JDK... " >&6; }
25902 25902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25903 25903 $as_echo "$BOOT_JDK" >&6; }
25904 25904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25905 25905 $as_echo_n "checking Boot JDK version... " >&6; }
25906 25906 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
25907 25907 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25908 25908 $as_echo "$BOOT_JDK_VERSION" >&6; }
25909 25909 fi # end check jdk version
25910 25910 fi # end check javac
25911 25911 fi # end check java
25912 25912 fi # end check boot jdk found
25913 25913 fi
25914 25914
25915 25915
25916 25916 # Test: Is $JAVA_HOME set?
25917 25917
25918 25918 if test "x$BOOT_JDK_FOUND" = xno; then
25919 25919 # Now execute the test
25920 25920
25921 25921 if test "x$JAVA_HOME" != x; then
25922 25922 JAVA_HOME_PROCESSED="$JAVA_HOME"
25923 25923
25924 25924 # Only process if variable expands to non-empty
25925 25925
25926 25926 if test "x$JAVA_HOME_PROCESSED" != x; then
25927 25927 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25928 25928
25929 25929 # Input might be given as Windows format, start by converting to
25930 25930 # unix format.
25931 25931 path="$JAVA_HOME_PROCESSED"
25932 25932 new_path=`$CYGPATH -u "$path"`
25933 25933
25934 25934 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25935 25935 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25936 25936 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25937 25937 # "foo.exe" is OK but "foo" is an error.
25938 25938 #
25939 25939 # This test is therefore slightly more accurate than "test -f" to check for file precense.
25940 25940 # It is also a way to make sure we got the proper file name for the real test later on.
25941 25941 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25942 25942 if test "x$test_shortpath" = x; then
25943 25943 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
25944 25944 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
25945 25945 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
25946 25946 fi
25947 25947
25948 25948 # Call helper function which possibly converts this using DOS-style short mode.
25949 25949 # If so, the updated path is stored in $new_path.
25950 25950
25951 25951 input_path="$new_path"
25952 25952 # Check if we need to convert this using DOS-style short mode. If the path
25953 25953 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25954 25954 # take no chances and rewrite it.
25955 25955 # Note: m4 eats our [], so we need to use [ and ] instead.
25956 25956 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25957 25957 if test "x$has_forbidden_chars" != x; then
25958 25958 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25959 25959 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25960 25960 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25961 25961 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25962 25962 # Going to short mode and back again did indeed matter. Since short mode is
25963 25963 # case insensitive, let's make it lowercase to improve readability.
25964 25964 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25965 25965 # Now convert it back to Unix-style (cygpath)
25966 25966 input_path=`$CYGPATH -u "$shortmode_path"`
25967 25967 new_path="$input_path"
25968 25968 fi
25969 25969 fi
25970 25970
25971 25971 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25972 25972 if test "x$test_cygdrive_prefix" = x; then
25973 25973 # As a simple fix, exclude /usr/bin since it's not a real path.
25974 25974 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25975 25975 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25976 25976 # a path prefixed by /cygdrive for fixpath to work.
25977 25977 new_path="$CYGWIN_ROOT_PATH$input_path"
25978 25978 fi
25979 25979 fi
25980 25980
25981 25981
25982 25982 if test "x$path" != "x$new_path"; then
25983 25983 JAVA_HOME_PROCESSED="$new_path"
25984 25984 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
25985 25985 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
25986 25986 fi
25987 25987
25988 25988 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25989 25989
25990 25990 path="$JAVA_HOME_PROCESSED"
25991 25991 has_colon=`$ECHO $path | $GREP ^.:`
25992 25992 new_path="$path"
25993 25993 if test "x$has_colon" = x; then
25994 25994 # Not in mixed or Windows style, start by that.
25995 25995 new_path=`cmd //c echo $path`
25996 25996 fi
25997 25997
25998 25998
25999 25999 input_path="$new_path"
26000 26000 # Check if we need to convert this using DOS-style short mode. If the path
26001 26001 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26002 26002 # take no chances and rewrite it.
26003 26003 # Note: m4 eats our [], so we need to use [ and ] instead.
26004 26004 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
26005 26005 if test "x$has_forbidden_chars" != x; then
26006 26006 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26007 26007 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26008 26008 fi
26009 26009
26010 26010
26011 26011 windows_path="$new_path"
26012 26012 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26013 26013 unix_path=`$CYGPATH -u "$windows_path"`
26014 26014 new_path="$unix_path"
26015 26015 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26016 26016 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26017 26017 new_path="$unix_path"
26018 26018 fi
26019 26019
26020 26020 if test "x$path" != "x$new_path"; then
26021 26021 JAVA_HOME_PROCESSED="$new_path"
26022 26022 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
26023 26023 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
26024 26024 fi
26025 26025
26026 26026 # Save the first 10 bytes of this path to the storage, so fixpath can work.
26027 26027 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
26028 26028
26029 26029 else
26030 26030 # We're on a unix platform. Hooray! :)
26031 26031 path="$JAVA_HOME_PROCESSED"
26032 26032 has_space=`$ECHO "$path" | $GREP " "`
26033 26033 if test "x$has_space" != x; then
26034 26034 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
26035 26035 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
26036 26036 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
26037 26037 fi
26038 26038
26039 26039 # Use eval to expand a potential ~
26040 26040 eval path="$path"
26041 26041 if test ! -f "$path" && test ! -d "$path"; then
26042 26042 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
26043 26043 fi
26044 26044
26045 26045 if test -d "$path"; then
26046 26046 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
26047 26047 else
26048 26048 dir="`$DIRNAME "$path"`"
26049 26049 base="`$BASENAME "$path"`"
26050 26050 JAVA_HOME_PROCESSED="`cd "$dir"; $THEPWDCMD -L`/$base"
26051 26051 fi
26052 26052 fi
26053 26053 fi
26054 26054
26055 26055 if test ! -d "$JAVA_HOME_PROCESSED"; then
26056 26056 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
26057 26057 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
26058 26058 else
26059 26059 # Aha, the user has set a JAVA_HOME
26060 26060 # let us use that as the Boot JDK.
26061 26061 BOOT_JDK="$JAVA_HOME_PROCESSED"
26062 26062 BOOT_JDK_FOUND=maybe
26063 26063 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
26064 26064 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
26065 26065 fi
26066 26066 fi
26067 26067
26068 26068
26069 26069 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
26070 26070 if test "x$BOOT_JDK_FOUND" = xmaybe; then
26071 26071 # Do we have a bin/java?
26072 26072 if test ! -x "$BOOT_JDK/bin/java"; then
26073 26073 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
26074 26074 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
26075 26075 BOOT_JDK_FOUND=no
26076 26076 else
26077 26077 # Do we have a bin/javac?
26078 26078 if test ! -x "$BOOT_JDK/bin/javac"; then
26079 26079 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
26080 26080 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
26081 26081 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
26082 26082 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
26083 26083 BOOT_JDK_FOUND=no
26084 26084 else
26085 26085 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
26086 26086 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
26087 26087
26088 26088 # Extra M4 quote needed to protect [] in grep expression.
26089 26089 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
26090 26090 if test "x$FOUND_CORRECT_VERSION" = x; then
26091 26091 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
26092 26092 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
26093 26093 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
26094 26094 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
26095 26095 BOOT_JDK_FOUND=no
26096 26096 else
26097 26097 # We're done! :-)
26098 26098 BOOT_JDK_FOUND=yes
26099 26099
26100 26100 # Only process if variable expands to non-empty
26101 26101
26102 26102 if test "x$BOOT_JDK" != x; then
26103 26103 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26104 26104
26105 26105 # Input might be given as Windows format, start by converting to
26106 26106 # unix format.
26107 26107 path="$BOOT_JDK"
26108 26108 new_path=`$CYGPATH -u "$path"`
26109 26109
26110 26110 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
26111 26111 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
26112 26112 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
26113 26113 # "foo.exe" is OK but "foo" is an error.
26114 26114 #
26115 26115 # This test is therefore slightly more accurate than "test -f" to check for file precense.
26116 26116 # It is also a way to make sure we got the proper file name for the real test later on.
26117 26117 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
26118 26118 if test "x$test_shortpath" = x; then
26119 26119 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26120 26120 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26121 26121 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
26122 26122 fi
26123 26123
26124 26124 # Call helper function which possibly converts this using DOS-style short mode.
26125 26125 # If so, the updated path is stored in $new_path.
26126 26126
26127 26127 input_path="$new_path"
26128 26128 # Check if we need to convert this using DOS-style short mode. If the path
26129 26129 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26130 26130 # take no chances and rewrite it.
26131 26131 # Note: m4 eats our [], so we need to use [ and ] instead.
26132 26132 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26133 26133 if test "x$has_forbidden_chars" != x; then
26134 26134 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26135 26135 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26136 26136 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26137 26137 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26138 26138 # Going to short mode and back again did indeed matter. Since short mode is
26139 26139 # case insensitive, let's make it lowercase to improve readability.
26140 26140 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26141 26141 # Now convert it back to Unix-style (cygpath)
26142 26142 input_path=`$CYGPATH -u "$shortmode_path"`
26143 26143 new_path="$input_path"
26144 26144 fi
26145 26145 fi
26146 26146
26147 26147 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26148 26148 if test "x$test_cygdrive_prefix" = x; then
26149 26149 # As a simple fix, exclude /usr/bin since it's not a real path.
26150 26150 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
26151 26151 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26152 26152 # a path prefixed by /cygdrive for fixpath to work.
26153 26153 new_path="$CYGWIN_ROOT_PATH$input_path"
26154 26154 fi
26155 26155 fi
26156 26156
26157 26157
26158 26158 if test "x$path" != "x$new_path"; then
26159 26159 BOOT_JDK="$new_path"
26160 26160 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26161 26161 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26162 26162 fi
26163 26163
26164 26164 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26165 26165
26166 26166 path="$BOOT_JDK"
26167 26167 has_colon=`$ECHO $path | $GREP ^.:`
26168 26168 new_path="$path"
26169 26169 if test "x$has_colon" = x; then
26170 26170 # Not in mixed or Windows style, start by that.
26171 26171 new_path=`cmd //c echo $path`
26172 26172 fi
26173 26173
26174 26174
26175 26175 input_path="$new_path"
26176 26176 # Check if we need to convert this using DOS-style short mode. If the path
26177 26177 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26178 26178 # take no chances and rewrite it.
26179 26179 # Note: m4 eats our [], so we need to use [ and ] instead.
26180 26180 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
26181 26181 if test "x$has_forbidden_chars" != x; then
26182 26182 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26183 26183 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26184 26184 fi
26185 26185
26186 26186
26187 26187 windows_path="$new_path"
26188 26188 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26189 26189 unix_path=`$CYGPATH -u "$windows_path"`
26190 26190 new_path="$unix_path"
26191 26191 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26192 26192 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26193 26193 new_path="$unix_path"
26194 26194 fi
26195 26195
26196 26196 if test "x$path" != "x$new_path"; then
26197 26197 BOOT_JDK="$new_path"
26198 26198 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26199 26199 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26200 26200 fi
26201 26201
26202 26202 # Save the first 10 bytes of this path to the storage, so fixpath can work.
26203 26203 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
26204 26204
26205 26205 else
26206 26206 # We're on a unix platform. Hooray! :)
26207 26207 path="$BOOT_JDK"
26208 26208 has_space=`$ECHO "$path" | $GREP " "`
26209 26209 if test "x$has_space" != x; then
26210 26210 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26211 26211 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26212 26212 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
26213 26213 fi
26214 26214
26215 26215 # Use eval to expand a potential ~
26216 26216 eval path="$path"
26217 26217 if test ! -f "$path" && test ! -d "$path"; then
26218 26218 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
26219 26219 fi
26220 26220
26221 26221 if test -d "$path"; then
26222 26222 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
26223 26223 else
26224 26224 dir="`$DIRNAME "$path"`"
26225 26225 base="`$BASENAME "$path"`"
26226 26226 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
26227 26227 fi
26228 26228 fi
26229 26229 fi
26230 26230
26231 26231 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
26232 26232 $as_echo_n "checking for Boot JDK... " >&6; }
26233 26233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
26234 26234 $as_echo "$BOOT_JDK" >&6; }
26235 26235 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
26236 26236 $as_echo_n "checking Boot JDK version... " >&6; }
26237 26237 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
26238 26238 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
26239 26239 $as_echo "$BOOT_JDK_VERSION" >&6; }
26240 26240 fi # end check jdk version
26241 26241 fi # end check javac
26242 26242 fi # end check java
26243 26243 fi # end check boot jdk found
26244 26244 fi
26245 26245
26246 26246
26247 26247 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
26248 26248
26249 26249 if test "x$BOOT_JDK_FOUND" = xno; then
26250 26250 # Now execute the test
26251 26251
26252 26252 # Extract the first word of "javac", so it can be a program name with args.
26253 26253 set dummy javac; ac_word=$2
26254 26254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26255 26255 $as_echo_n "checking for $ac_word... " >&6; }
26256 26256 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
26257 26257 $as_echo_n "(cached) " >&6
26258 26258 else
26259 26259 case $JAVAC_CHECK in
26260 26260 [\\/]* | ?:[\\/]*)
26261 26261 ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
26262 26262 ;;
26263 26263 *)
26264 26264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26265 26265 for as_dir in $PATH
26266 26266 do
26267 26267 IFS=$as_save_IFS
26268 26268 test -z "$as_dir" && as_dir=.
26269 26269 for ac_exec_ext in '' $ac_executable_extensions; do
26270 26270 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26271 26271 ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
26272 26272 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26273 26273 break 2
26274 26274 fi
26275 26275 done
26276 26276 done
26277 26277 IFS=$as_save_IFS
26278 26278
26279 26279 ;;
26280 26280 esac
26281 26281 fi
26282 26282 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
26283 26283 if test -n "$JAVAC_CHECK"; then
26284 26284 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
26285 26285 $as_echo "$JAVAC_CHECK" >&6; }
26286 26286 else
26287 26287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26288 26288 $as_echo "no" >&6; }
26289 26289 fi
26290 26290
26291 26291
26292 26292 # Extract the first word of "java", so it can be a program name with args.
26293 26293 set dummy java; ac_word=$2
26294 26294 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
26295 26295 $as_echo_n "checking for $ac_word... " >&6; }
26296 26296 if ${ac_cv_path_JAVA_CHECK+:} false; then :
26297 26297 $as_echo_n "(cached) " >&6
26298 26298 else
26299 26299 case $JAVA_CHECK in
26300 26300 [\\/]* | ?:[\\/]*)
26301 26301 ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
26302 26302 ;;
26303 26303 *)
26304 26304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
26305 26305 for as_dir in $PATH
26306 26306 do
26307 26307 IFS=$as_save_IFS
26308 26308 test -z "$as_dir" && as_dir=.
26309 26309 for ac_exec_ext in '' $ac_executable_extensions; do
26310 26310 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
26311 26311 ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
26312 26312 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
26313 26313 break 2
26314 26314 fi
26315 26315 done
26316 26316 done
26317 26317 IFS=$as_save_IFS
26318 26318
26319 26319 ;;
26320 26320 esac
26321 26321 fi
26322 26322 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
26323 26323 if test -n "$JAVA_CHECK"; then
26324 26324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
26325 26325 $as_echo "$JAVA_CHECK" >&6; }
26326 26326 else
26327 26327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
26328 26328 $as_echo "no" >&6; }
26329 26329 fi
26330 26330
26331 26331
26332 26332 BINARY="$JAVAC_CHECK"
26333 26333 if test "x$JAVAC_CHECK" = x; then
26334 26334 BINARY="$JAVA_CHECK"
26335 26335 fi
26336 26336 if test "x$BINARY" != x; then
26337 26337 # So there is a java(c) binary, it might be part of a JDK.
26338 26338 # Lets find the JDK/JRE directory by following symbolic links.
26339 26339 # Linux/GNU systems often have links from /usr/bin/java to
26340 26340 # /etc/alternatives/java to the real JDK binary.
26341 26341
26342 26342 if test "x$OPENJDK_BUILD_OS" != xwindows; then
26343 26343 # Follow a chain of symbolic links. Use readlink
26344 26344 # where it exists, else fall back to horribly
26345 26345 # complicated shell code.
26346 26346 if test "x$READLINK_TESTED" != yes; then
26347 26347 # On MacOSX there is a readlink tool with a different
26348 26348 # purpose than the GNU readlink tool. Check the found readlink.
26349 26349 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
26350 26350 if test "x$ISGNU" = x; then
26351 26351 # A readlink that we do not know how to use.
26352 26352 # Are there other non-GNU readlinks out there?
26353 26353 READLINK_TESTED=yes
26354 26354 READLINK=
26355 26355 fi
26356 26356 fi
26357 26357
26358 26358 if test "x$READLINK" != x; then
26359 26359 BINARY=`$READLINK -f $BINARY`
26360 26360 else
26361 26361 # Save the current directory for restoring afterwards
26362 26362 STARTDIR=$PWD
26363 26363 COUNTER=0
26364 26364 sym_link_dir=`$DIRNAME $BINARY`
26365 26365 sym_link_file=`$BASENAME $BINARY`
26366 26366 cd $sym_link_dir
26367 26367 # Use -P flag to resolve symlinks in directories.
26368 26368 cd `$THEPWDCMD -P`
26369 26369 sym_link_dir=`$THEPWDCMD -P`
26370 26370 # Resolve file symlinks
26371 26371 while test $COUNTER -lt 20; do
26372 26372 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
26373 26373 if test "x$ISLINK" == x; then
26374 26374 # This is not a symbolic link! We are done!
26375 26375 break
26376 26376 fi
26377 26377 # Again resolve directory symlinks since the target of the just found
26378 26378 # link could be in a different directory
26379 26379 cd `$DIRNAME $ISLINK`
26380 26380 sym_link_dir=`$THEPWDCMD -P`
26381 26381 sym_link_file=`$BASENAME $ISLINK`
26382 26382 let COUNTER=COUNTER+1
26383 26383 done
26384 26384 cd $STARTDIR
26385 26385 BINARY=$sym_link_dir/$sym_link_file
26386 26386 fi
26387 26387 fi
26388 26388
26389 26389 BOOT_JDK=`dirname "$BINARY"`
26390 26390 BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
26391 26391 if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
26392 26392 # Looks like we found ourselves an JDK
26393 26393 BOOT_JDK_FOUND=maybe
26394 26394 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
26395 26395 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
26396 26396 fi
26397 26397 fi
26398 26398
26399 26399
26400 26400 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
26401 26401 if test "x$BOOT_JDK_FOUND" = xmaybe; then
26402 26402 # Do we have a bin/java?
26403 26403 if test ! -x "$BOOT_JDK/bin/java"; then
26404 26404 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
26405 26405 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
26406 26406 BOOT_JDK_FOUND=no
26407 26407 else
26408 26408 # Do we have a bin/javac?
26409 26409 if test ! -x "$BOOT_JDK/bin/javac"; then
26410 26410 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
26411 26411 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
26412 26412 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
26413 26413 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
26414 26414 BOOT_JDK_FOUND=no
26415 26415 else
26416 26416 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
26417 26417 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
26418 26418
26419 26419 # Extra M4 quote needed to protect [] in grep expression.
26420 26420 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
26421 26421 if test "x$FOUND_CORRECT_VERSION" = x; then
26422 26422 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
26423 26423 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
26424 26424 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
26425 26425 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
26426 26426 BOOT_JDK_FOUND=no
26427 26427 else
26428 26428 # We're done! :-)
26429 26429 BOOT_JDK_FOUND=yes
26430 26430
26431 26431 # Only process if variable expands to non-empty
26432 26432
26433 26433 if test "x$BOOT_JDK" != x; then
26434 26434 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26435 26435
26436 26436 # Input might be given as Windows format, start by converting to
26437 26437 # unix format.
26438 26438 path="$BOOT_JDK"
26439 26439 new_path=`$CYGPATH -u "$path"`
26440 26440
26441 26441 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
26442 26442 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
26443 26443 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
26444 26444 # "foo.exe" is OK but "foo" is an error.
26445 26445 #
26446 26446 # This test is therefore slightly more accurate than "test -f" to check for file precense.
26447 26447 # It is also a way to make sure we got the proper file name for the real test later on.
26448 26448 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
26449 26449 if test "x$test_shortpath" = x; then
26450 26450 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26451 26451 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26452 26452 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
26453 26453 fi
26454 26454
26455 26455 # Call helper function which possibly converts this using DOS-style short mode.
26456 26456 # If so, the updated path is stored in $new_path.
26457 26457
26458 26458 input_path="$new_path"
26459 26459 # Check if we need to convert this using DOS-style short mode. If the path
26460 26460 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26461 26461 # take no chances and rewrite it.
26462 26462 # Note: m4 eats our [], so we need to use [ and ] instead.
26463 26463 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26464 26464 if test "x$has_forbidden_chars" != x; then
26465 26465 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26466 26466 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26467 26467 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26468 26468 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26469 26469 # Going to short mode and back again did indeed matter. Since short mode is
26470 26470 # case insensitive, let's make it lowercase to improve readability.
26471 26471 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26472 26472 # Now convert it back to Unix-style (cygpath)
26473 26473 input_path=`$CYGPATH -u "$shortmode_path"`
26474 26474 new_path="$input_path"
26475 26475 fi
26476 26476 fi
26477 26477
26478 26478 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26479 26479 if test "x$test_cygdrive_prefix" = x; then
26480 26480 # As a simple fix, exclude /usr/bin since it's not a real path.
26481 26481 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
26482 26482 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26483 26483 # a path prefixed by /cygdrive for fixpath to work.
26484 26484 new_path="$CYGWIN_ROOT_PATH$input_path"
26485 26485 fi
26486 26486 fi
26487 26487
26488 26488
26489 26489 if test "x$path" != "x$new_path"; then
26490 26490 BOOT_JDK="$new_path"
26491 26491 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26492 26492 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26493 26493 fi
26494 26494
26495 26495 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26496 26496
26497 26497 path="$BOOT_JDK"
26498 26498 has_colon=`$ECHO $path | $GREP ^.:`
26499 26499 new_path="$path"
26500 26500 if test "x$has_colon" = x; then
26501 26501 # Not in mixed or Windows style, start by that.
26502 26502 new_path=`cmd //c echo $path`
26503 26503 fi
26504 26504
26505 26505
26506 26506 input_path="$new_path"
26507 26507 # Check if we need to convert this using DOS-style short mode. If the path
26508 26508 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26509 26509 # take no chances and rewrite it.
26510 26510 # Note: m4 eats our [], so we need to use [ and ] instead.
26511 26511 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
26512 26512 if test "x$has_forbidden_chars" != x; then
26513 26513 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26514 26514 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26515 26515 fi
26516 26516
26517 26517
26518 26518 windows_path="$new_path"
26519 26519 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26520 26520 unix_path=`$CYGPATH -u "$windows_path"`
26521 26521 new_path="$unix_path"
26522 26522 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26523 26523 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26524 26524 new_path="$unix_path"
26525 26525 fi
26526 26526
26527 26527 if test "x$path" != "x$new_path"; then
26528 26528 BOOT_JDK="$new_path"
26529 26529 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26530 26530 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26531 26531 fi
26532 26532
26533 26533 # Save the first 10 bytes of this path to the storage, so fixpath can work.
26534 26534 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
26535 26535
26536 26536 else
26537 26537 # We're on a unix platform. Hooray! :)
26538 26538 path="$BOOT_JDK"
26539 26539 has_space=`$ECHO "$path" | $GREP " "`
26540 26540 if test "x$has_space" != x; then
26541 26541 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26542 26542 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26543 26543 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
26544 26544 fi
26545 26545
26546 26546 # Use eval to expand a potential ~
26547 26547 eval path="$path"
26548 26548 if test ! -f "$path" && test ! -d "$path"; then
26549 26549 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
26550 26550 fi
26551 26551
26552 26552 if test -d "$path"; then
26553 26553 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
26554 26554 else
26555 26555 dir="`$DIRNAME "$path"`"
26556 26556 base="`$BASENAME "$path"`"
26557 26557 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
26558 26558 fi
26559 26559 fi
26560 26560 fi
26561 26561
26562 26562 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
26563 26563 $as_echo_n "checking for Boot JDK... " >&6; }
26564 26564 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
26565 26565 $as_echo "$BOOT_JDK" >&6; }
26566 26566 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
26567 26567 $as_echo_n "checking Boot JDK version... " >&6; }
26568 26568 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
26569 26569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
26570 26570 $as_echo "$BOOT_JDK_VERSION" >&6; }
26571 26571 fi # end check jdk version
26572 26572 fi # end check javac
26573 26573 fi # end check java
26574 26574 fi # end check boot jdk found
26575 26575 fi
26576 26576
26577 26577
26578 26578 # Test: Is there a JDK installed in default, well-known locations?
26579 26579
26580 26580 if test "x$BOOT_JDK_FOUND" = xno; then
26581 26581 # Now execute the test
26582 26582
26583 26583 if test "x$OPENJDK_TARGET_OS" = xwindows; then
26584 26584
26585 26585 if test "x$BOOT_JDK_FOUND" = xno; then
26586 26586 # Now execute the test
26587 26587
26588 26588 if test "x$ProgramW6432" != x; then
26589 26589 VIRTUAL_DIR="$ProgramW6432/Java"
26590 26590
26591 26591 windows_path="$VIRTUAL_DIR"
26592 26592 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26593 26593 unix_path=`$CYGPATH -u "$windows_path"`
26594 26594 VIRTUAL_DIR="$unix_path"
26595 26595 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26596 26596 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26597 26597 VIRTUAL_DIR="$unix_path"
26598 26598 fi
26599 26599
26600 26600
26601 26601 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
26602 26602 BOOT_JDK_SUFFIX=""
26603 26603 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
26604 26604 if test "x$ALL_JDKS_FOUND" != x; then
26605 26605 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
26606 26606
26607 26607 if test "x$BOOT_JDK_FOUND" = xno; then
26608 26608 # Now execute the test
26609 26609
26610 26610 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
26611 26611 if test -d "$BOOT_JDK"; then
26612 26612 BOOT_JDK_FOUND=maybe
26613 26613 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
26614 26614 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
26615 26615 fi
26616 26616
26617 26617
26618 26618 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
26619 26619 if test "x$BOOT_JDK_FOUND" = xmaybe; then
26620 26620 # Do we have a bin/java?
26621 26621 if test ! -x "$BOOT_JDK/bin/java"; then
26622 26622 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
26623 26623 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
26624 26624 BOOT_JDK_FOUND=no
26625 26625 else
26626 26626 # Do we have a bin/javac?
26627 26627 if test ! -x "$BOOT_JDK/bin/javac"; then
26628 26628 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
26629 26629 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
26630 26630 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
26631 26631 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
26632 26632 BOOT_JDK_FOUND=no
26633 26633 else
26634 26634 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
26635 26635 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
26636 26636
26637 26637 # Extra M4 quote needed to protect [] in grep expression.
26638 26638 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
26639 26639 if test "x$FOUND_CORRECT_VERSION" = x; then
26640 26640 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
26641 26641 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
26642 26642 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
26643 26643 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
26644 26644 BOOT_JDK_FOUND=no
26645 26645 else
26646 26646 # We're done! :-)
26647 26647 BOOT_JDK_FOUND=yes
26648 26648
26649 26649 # Only process if variable expands to non-empty
26650 26650
26651 26651 if test "x$BOOT_JDK" != x; then
26652 26652 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26653 26653
26654 26654 # Input might be given as Windows format, start by converting to
26655 26655 # unix format.
26656 26656 path="$BOOT_JDK"
26657 26657 new_path=`$CYGPATH -u "$path"`
26658 26658
26659 26659 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
26660 26660 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
26661 26661 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
26662 26662 # "foo.exe" is OK but "foo" is an error.
26663 26663 #
26664 26664 # This test is therefore slightly more accurate than "test -f" to check for file precense.
26665 26665 # It is also a way to make sure we got the proper file name for the real test later on.
26666 26666 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
26667 26667 if test "x$test_shortpath" = x; then
26668 26668 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26669 26669 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26670 26670 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
26671 26671 fi
26672 26672
26673 26673 # Call helper function which possibly converts this using DOS-style short mode.
26674 26674 # If so, the updated path is stored in $new_path.
26675 26675
26676 26676 input_path="$new_path"
26677 26677 # Check if we need to convert this using DOS-style short mode. If the path
26678 26678 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26679 26679 # take no chances and rewrite it.
26680 26680 # Note: m4 eats our [], so we need to use [ and ] instead.
26681 26681 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26682 26682 if test "x$has_forbidden_chars" != x; then
26683 26683 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26684 26684 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26685 26685 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26686 26686 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26687 26687 # Going to short mode and back again did indeed matter. Since short mode is
26688 26688 # case insensitive, let's make it lowercase to improve readability.
26689 26689 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26690 26690 # Now convert it back to Unix-style (cygpath)
26691 26691 input_path=`$CYGPATH -u "$shortmode_path"`
26692 26692 new_path="$input_path"
26693 26693 fi
26694 26694 fi
26695 26695
26696 26696 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26697 26697 if test "x$test_cygdrive_prefix" = x; then
26698 26698 # As a simple fix, exclude /usr/bin since it's not a real path.
26699 26699 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
26700 26700 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26701 26701 # a path prefixed by /cygdrive for fixpath to work.
26702 26702 new_path="$CYGWIN_ROOT_PATH$input_path"
26703 26703 fi
26704 26704 fi
26705 26705
26706 26706
26707 26707 if test "x$path" != "x$new_path"; then
26708 26708 BOOT_JDK="$new_path"
26709 26709 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26710 26710 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26711 26711 fi
26712 26712
26713 26713 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26714 26714
26715 26715 path="$BOOT_JDK"
26716 26716 has_colon=`$ECHO $path | $GREP ^.:`
26717 26717 new_path="$path"
26718 26718 if test "x$has_colon" = x; then
26719 26719 # Not in mixed or Windows style, start by that.
26720 26720 new_path=`cmd //c echo $path`
26721 26721 fi
26722 26722
26723 26723
26724 26724 input_path="$new_path"
26725 26725 # Check if we need to convert this using DOS-style short mode. If the path
26726 26726 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26727 26727 # take no chances and rewrite it.
26728 26728 # Note: m4 eats our [], so we need to use [ and ] instead.
26729 26729 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
26730 26730 if test "x$has_forbidden_chars" != x; then
26731 26731 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26732 26732 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26733 26733 fi
26734 26734
26735 26735
26736 26736 windows_path="$new_path"
26737 26737 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26738 26738 unix_path=`$CYGPATH -u "$windows_path"`
26739 26739 new_path="$unix_path"
26740 26740 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26741 26741 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26742 26742 new_path="$unix_path"
26743 26743 fi
26744 26744
26745 26745 if test "x$path" != "x$new_path"; then
26746 26746 BOOT_JDK="$new_path"
26747 26747 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26748 26748 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26749 26749 fi
26750 26750
26751 26751 # Save the first 10 bytes of this path to the storage, so fixpath can work.
26752 26752 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
26753 26753
26754 26754 else
26755 26755 # We're on a unix platform. Hooray! :)
26756 26756 path="$BOOT_JDK"
26757 26757 has_space=`$ECHO "$path" | $GREP " "`
26758 26758 if test "x$has_space" != x; then
26759 26759 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26760 26760 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26761 26761 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
26762 26762 fi
26763 26763
26764 26764 # Use eval to expand a potential ~
26765 26765 eval path="$path"
26766 26766 if test ! -f "$path" && test ! -d "$path"; then
26767 26767 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
26768 26768 fi
26769 26769
26770 26770 if test -d "$path"; then
26771 26771 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
26772 26772 else
26773 26773 dir="`$DIRNAME "$path"`"
26774 26774 base="`$BASENAME "$path"`"
26775 26775 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
26776 26776 fi
26777 26777 fi
26778 26778 fi
26779 26779
26780 26780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
26781 26781 $as_echo_n "checking for Boot JDK... " >&6; }
26782 26782 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
26783 26783 $as_echo "$BOOT_JDK" >&6; }
26784 26784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
26785 26785 $as_echo_n "checking Boot JDK version... " >&6; }
26786 26786 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
26787 26787 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
26788 26788 $as_echo "$BOOT_JDK_VERSION" >&6; }
26789 26789 fi # end check jdk version
26790 26790 fi # end check javac
26791 26791 fi # end check java
26792 26792 fi # end check boot jdk found
26793 26793 fi
26794 26794
26795 26795 done
26796 26796 fi
26797 26797
26798 26798 fi
26799 26799
26800 26800
26801 26801 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
26802 26802 if test "x$BOOT_JDK_FOUND" = xmaybe; then
26803 26803 # Do we have a bin/java?
26804 26804 if test ! -x "$BOOT_JDK/bin/java"; then
26805 26805 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
26806 26806 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
26807 26807 BOOT_JDK_FOUND=no
26808 26808 else
26809 26809 # Do we have a bin/javac?
26810 26810 if test ! -x "$BOOT_JDK/bin/javac"; then
26811 26811 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
26812 26812 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
26813 26813 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
26814 26814 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
26815 26815 BOOT_JDK_FOUND=no
26816 26816 else
26817 26817 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
26818 26818 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
26819 26819
26820 26820 # Extra M4 quote needed to protect [] in grep expression.
26821 26821 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
26822 26822 if test "x$FOUND_CORRECT_VERSION" = x; then
26823 26823 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
26824 26824 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
26825 26825 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
26826 26826 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
26827 26827 BOOT_JDK_FOUND=no
26828 26828 else
26829 26829 # We're done! :-)
26830 26830 BOOT_JDK_FOUND=yes
26831 26831
26832 26832 # Only process if variable expands to non-empty
26833 26833
26834 26834 if test "x$BOOT_JDK" != x; then
26835 26835 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26836 26836
26837 26837 # Input might be given as Windows format, start by converting to
26838 26838 # unix format.
26839 26839 path="$BOOT_JDK"
26840 26840 new_path=`$CYGPATH -u "$path"`
26841 26841
26842 26842 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
26843 26843 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
26844 26844 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
26845 26845 # "foo.exe" is OK but "foo" is an error.
26846 26846 #
26847 26847 # This test is therefore slightly more accurate than "test -f" to check for file precense.
26848 26848 # It is also a way to make sure we got the proper file name for the real test later on.
26849 26849 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
26850 26850 if test "x$test_shortpath" = x; then
26851 26851 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26852 26852 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26853 26853 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
26854 26854 fi
26855 26855
26856 26856 # Call helper function which possibly converts this using DOS-style short mode.
26857 26857 # If so, the updated path is stored in $new_path.
26858 26858
26859 26859 input_path="$new_path"
26860 26860 # Check if we need to convert this using DOS-style short mode. If the path
26861 26861 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26862 26862 # take no chances and rewrite it.
26863 26863 # Note: m4 eats our [], so we need to use [ and ] instead.
26864 26864 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26865 26865 if test "x$has_forbidden_chars" != x; then
26866 26866 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26867 26867 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26868 26868 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26869 26869 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26870 26870 # Going to short mode and back again did indeed matter. Since short mode is
26871 26871 # case insensitive, let's make it lowercase to improve readability.
26872 26872 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26873 26873 # Now convert it back to Unix-style (cygpath)
26874 26874 input_path=`$CYGPATH -u "$shortmode_path"`
26875 26875 new_path="$input_path"
26876 26876 fi
26877 26877 fi
26878 26878
26879 26879 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26880 26880 if test "x$test_cygdrive_prefix" = x; then
26881 26881 # As a simple fix, exclude /usr/bin since it's not a real path.
26882 26882 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
26883 26883 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26884 26884 # a path prefixed by /cygdrive for fixpath to work.
26885 26885 new_path="$CYGWIN_ROOT_PATH$input_path"
26886 26886 fi
26887 26887 fi
26888 26888
26889 26889
26890 26890 if test "x$path" != "x$new_path"; then
26891 26891 BOOT_JDK="$new_path"
26892 26892 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26893 26893 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26894 26894 fi
26895 26895
26896 26896 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26897 26897
26898 26898 path="$BOOT_JDK"
26899 26899 has_colon=`$ECHO $path | $GREP ^.:`
26900 26900 new_path="$path"
26901 26901 if test "x$has_colon" = x; then
26902 26902 # Not in mixed or Windows style, start by that.
26903 26903 new_path=`cmd //c echo $path`
26904 26904 fi
26905 26905
26906 26906
26907 26907 input_path="$new_path"
26908 26908 # Check if we need to convert this using DOS-style short mode. If the path
26909 26909 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26910 26910 # take no chances and rewrite it.
26911 26911 # Note: m4 eats our [], so we need to use [ and ] instead.
26912 26912 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
26913 26913 if test "x$has_forbidden_chars" != x; then
26914 26914 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26915 26915 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26916 26916 fi
26917 26917
26918 26918
26919 26919 windows_path="$new_path"
26920 26920 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26921 26921 unix_path=`$CYGPATH -u "$windows_path"`
26922 26922 new_path="$unix_path"
26923 26923 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26924 26924 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26925 26925 new_path="$unix_path"
26926 26926 fi
26927 26927
26928 26928 if test "x$path" != "x$new_path"; then
26929 26929 BOOT_JDK="$new_path"
26930 26930 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
26931 26931 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
26932 26932 fi
26933 26933
26934 26934 # Save the first 10 bytes of this path to the storage, so fixpath can work.
26935 26935 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
26936 26936
26937 26937 else
26938 26938 # We're on a unix platform. Hooray! :)
26939 26939 path="$BOOT_JDK"
26940 26940 has_space=`$ECHO "$path" | $GREP " "`
26941 26941 if test "x$has_space" != x; then
26942 26942 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
26943 26943 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
26944 26944 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
26945 26945 fi
26946 26946
26947 26947 # Use eval to expand a potential ~
26948 26948 eval path="$path"
26949 26949 if test ! -f "$path" && test ! -d "$path"; then
26950 26950 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
26951 26951 fi
26952 26952
26953 26953 if test -d "$path"; then
26954 26954 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
26955 26955 else
26956 26956 dir="`$DIRNAME "$path"`"
26957 26957 base="`$BASENAME "$path"`"
26958 26958 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
26959 26959 fi
26960 26960 fi
26961 26961 fi
26962 26962
26963 26963 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
26964 26964 $as_echo_n "checking for Boot JDK... " >&6; }
26965 26965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
26966 26966 $as_echo "$BOOT_JDK" >&6; }
26967 26967 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
26968 26968 $as_echo_n "checking Boot JDK version... " >&6; }
26969 26969 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
26970 26970 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
26971 26971 $as_echo "$BOOT_JDK_VERSION" >&6; }
26972 26972 fi # end check jdk version
26973 26973 fi # end check javac
26974 26974 fi # end check java
26975 26975 fi # end check boot jdk found
26976 26976 fi
26977 26977
26978 26978
26979 26979 if test "x$BOOT_JDK_FOUND" = xno; then
26980 26980 # Now execute the test
26981 26981
26982 26982 if test "x$PROGRAMW6432" != x; then
26983 26983 VIRTUAL_DIR="$PROGRAMW6432/Java"
26984 26984
26985 26985 windows_path="$VIRTUAL_DIR"
26986 26986 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26987 26987 unix_path=`$CYGPATH -u "$windows_path"`
26988 26988 VIRTUAL_DIR="$unix_path"
26989 26989 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26990 26990 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
26991 26991 VIRTUAL_DIR="$unix_path"
26992 26992 fi
26993 26993
26994 26994
26995 26995 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
26996 26996 BOOT_JDK_SUFFIX=""
26997 26997 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
26998 26998 if test "x$ALL_JDKS_FOUND" != x; then
26999 26999 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
27000 27000
27001 27001 if test "x$BOOT_JDK_FOUND" = xno; then
27002 27002 # Now execute the test
27003 27003
27004 27004 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
27005 27005 if test -d "$BOOT_JDK"; then
27006 27006 BOOT_JDK_FOUND=maybe
27007 27007 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
27008 27008 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
27009 27009 fi
27010 27010
27011 27011
27012 27012 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27013 27013 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27014 27014 # Do we have a bin/java?
27015 27015 if test ! -x "$BOOT_JDK/bin/java"; then
27016 27016 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27017 27017 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27018 27018 BOOT_JDK_FOUND=no
27019 27019 else
27020 27020 # Do we have a bin/javac?
27021 27021 if test ! -x "$BOOT_JDK/bin/javac"; then
27022 27022 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27023 27023 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27024 27024 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27025 27025 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27026 27026 BOOT_JDK_FOUND=no
27027 27027 else
27028 27028 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
27029 27029 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
27030 27030
27031 27031 # Extra M4 quote needed to protect [] in grep expression.
27032 27032 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
27033 27033 if test "x$FOUND_CORRECT_VERSION" = x; then
27034 27034 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
27035 27035 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
27036 27036 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
27037 27037 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
27038 27038 BOOT_JDK_FOUND=no
27039 27039 else
27040 27040 # We're done! :-)
27041 27041 BOOT_JDK_FOUND=yes
27042 27042
27043 27043 # Only process if variable expands to non-empty
27044 27044
27045 27045 if test "x$BOOT_JDK" != x; then
27046 27046 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27047 27047
27048 27048 # Input might be given as Windows format, start by converting to
27049 27049 # unix format.
27050 27050 path="$BOOT_JDK"
27051 27051 new_path=`$CYGPATH -u "$path"`
27052 27052
27053 27053 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
27054 27054 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
27055 27055 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
27056 27056 # "foo.exe" is OK but "foo" is an error.
27057 27057 #
27058 27058 # This test is therefore slightly more accurate than "test -f" to check for file precense.
27059 27059 # It is also a way to make sure we got the proper file name for the real test later on.
27060 27060 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
27061 27061 if test "x$test_shortpath" = x; then
27062 27062 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27063 27063 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27064 27064 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
27065 27065 fi
27066 27066
27067 27067 # Call helper function which possibly converts this using DOS-style short mode.
27068 27068 # If so, the updated path is stored in $new_path.
27069 27069
27070 27070 input_path="$new_path"
27071 27071 # Check if we need to convert this using DOS-style short mode. If the path
27072 27072 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27073 27073 # take no chances and rewrite it.
27074 27074 # Note: m4 eats our [], so we need to use [ and ] instead.
27075 27075 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27076 27076 if test "x$has_forbidden_chars" != x; then
27077 27077 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27078 27078 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27079 27079 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27080 27080 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27081 27081 # Going to short mode and back again did indeed matter. Since short mode is
27082 27082 # case insensitive, let's make it lowercase to improve readability.
27083 27083 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27084 27084 # Now convert it back to Unix-style (cygpath)
27085 27085 input_path=`$CYGPATH -u "$shortmode_path"`
27086 27086 new_path="$input_path"
27087 27087 fi
27088 27088 fi
27089 27089
27090 27090 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27091 27091 if test "x$test_cygdrive_prefix" = x; then
27092 27092 # As a simple fix, exclude /usr/bin since it's not a real path.
27093 27093 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
27094 27094 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27095 27095 # a path prefixed by /cygdrive for fixpath to work.
27096 27096 new_path="$CYGWIN_ROOT_PATH$input_path"
27097 27097 fi
27098 27098 fi
27099 27099
27100 27100
27101 27101 if test "x$path" != "x$new_path"; then
27102 27102 BOOT_JDK="$new_path"
27103 27103 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27104 27104 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27105 27105 fi
27106 27106
27107 27107 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27108 27108
27109 27109 path="$BOOT_JDK"
27110 27110 has_colon=`$ECHO $path | $GREP ^.:`
27111 27111 new_path="$path"
27112 27112 if test "x$has_colon" = x; then
27113 27113 # Not in mixed or Windows style, start by that.
27114 27114 new_path=`cmd //c echo $path`
27115 27115 fi
27116 27116
27117 27117
27118 27118 input_path="$new_path"
27119 27119 # Check if we need to convert this using DOS-style short mode. If the path
27120 27120 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27121 27121 # take no chances and rewrite it.
27122 27122 # Note: m4 eats our [], so we need to use [ and ] instead.
27123 27123 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
27124 27124 if test "x$has_forbidden_chars" != x; then
27125 27125 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27126 27126 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27127 27127 fi
27128 27128
27129 27129
27130 27130 windows_path="$new_path"
27131 27131 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27132 27132 unix_path=`$CYGPATH -u "$windows_path"`
27133 27133 new_path="$unix_path"
27134 27134 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27135 27135 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27136 27136 new_path="$unix_path"
27137 27137 fi
27138 27138
27139 27139 if test "x$path" != "x$new_path"; then
27140 27140 BOOT_JDK="$new_path"
27141 27141 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27142 27142 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27143 27143 fi
27144 27144
27145 27145 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27146 27146 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27147 27147
27148 27148 else
27149 27149 # We're on a unix platform. Hooray! :)
27150 27150 path="$BOOT_JDK"
27151 27151 has_space=`$ECHO "$path" | $GREP " "`
27152 27152 if test "x$has_space" != x; then
27153 27153 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27154 27154 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27155 27155 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
27156 27156 fi
27157 27157
27158 27158 # Use eval to expand a potential ~
27159 27159 eval path="$path"
27160 27160 if test ! -f "$path" && test ! -d "$path"; then
27161 27161 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
27162 27162 fi
27163 27163
27164 27164 if test -d "$path"; then
27165 27165 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
27166 27166 else
27167 27167 dir="`$DIRNAME "$path"`"
27168 27168 base="`$BASENAME "$path"`"
27169 27169 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
27170 27170 fi
27171 27171 fi
27172 27172 fi
27173 27173
27174 27174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
27175 27175 $as_echo_n "checking for Boot JDK... " >&6; }
27176 27176 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27177 27177 $as_echo "$BOOT_JDK" >&6; }
27178 27178 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
27179 27179 $as_echo_n "checking Boot JDK version... " >&6; }
27180 27180 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
27181 27181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
27182 27182 $as_echo "$BOOT_JDK_VERSION" >&6; }
27183 27183 fi # end check jdk version
27184 27184 fi # end check javac
27185 27185 fi # end check java
27186 27186 fi # end check boot jdk found
27187 27187 fi
27188 27188
27189 27189 done
27190 27190 fi
27191 27191
27192 27192 fi
27193 27193
27194 27194
27195 27195 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27196 27196 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27197 27197 # Do we have a bin/java?
27198 27198 if test ! -x "$BOOT_JDK/bin/java"; then
27199 27199 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27200 27200 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27201 27201 BOOT_JDK_FOUND=no
27202 27202 else
27203 27203 # Do we have a bin/javac?
27204 27204 if test ! -x "$BOOT_JDK/bin/javac"; then
27205 27205 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27206 27206 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27207 27207 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27208 27208 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27209 27209 BOOT_JDK_FOUND=no
27210 27210 else
27211 27211 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
27212 27212 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
27213 27213
27214 27214 # Extra M4 quote needed to protect [] in grep expression.
27215 27215 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
27216 27216 if test "x$FOUND_CORRECT_VERSION" = x; then
27217 27217 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
27218 27218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
27219 27219 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
27220 27220 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
27221 27221 BOOT_JDK_FOUND=no
27222 27222 else
27223 27223 # We're done! :-)
27224 27224 BOOT_JDK_FOUND=yes
27225 27225
27226 27226 # Only process if variable expands to non-empty
27227 27227
27228 27228 if test "x$BOOT_JDK" != x; then
27229 27229 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27230 27230
27231 27231 # Input might be given as Windows format, start by converting to
27232 27232 # unix format.
27233 27233 path="$BOOT_JDK"
27234 27234 new_path=`$CYGPATH -u "$path"`
27235 27235
27236 27236 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
27237 27237 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
27238 27238 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
27239 27239 # "foo.exe" is OK but "foo" is an error.
27240 27240 #
27241 27241 # This test is therefore slightly more accurate than "test -f" to check for file precense.
27242 27242 # It is also a way to make sure we got the proper file name for the real test later on.
27243 27243 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
27244 27244 if test "x$test_shortpath" = x; then
27245 27245 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27246 27246 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27247 27247 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
27248 27248 fi
27249 27249
27250 27250 # Call helper function which possibly converts this using DOS-style short mode.
27251 27251 # If so, the updated path is stored in $new_path.
27252 27252
27253 27253 input_path="$new_path"
27254 27254 # Check if we need to convert this using DOS-style short mode. If the path
27255 27255 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27256 27256 # take no chances and rewrite it.
27257 27257 # Note: m4 eats our [], so we need to use [ and ] instead.
27258 27258 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27259 27259 if test "x$has_forbidden_chars" != x; then
27260 27260 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27261 27261 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27262 27262 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27263 27263 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27264 27264 # Going to short mode and back again did indeed matter. Since short mode is
27265 27265 # case insensitive, let's make it lowercase to improve readability.
27266 27266 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27267 27267 # Now convert it back to Unix-style (cygpath)
27268 27268 input_path=`$CYGPATH -u "$shortmode_path"`
27269 27269 new_path="$input_path"
27270 27270 fi
27271 27271 fi
27272 27272
27273 27273 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27274 27274 if test "x$test_cygdrive_prefix" = x; then
27275 27275 # As a simple fix, exclude /usr/bin since it's not a real path.
27276 27276 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
27277 27277 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27278 27278 # a path prefixed by /cygdrive for fixpath to work.
27279 27279 new_path="$CYGWIN_ROOT_PATH$input_path"
27280 27280 fi
27281 27281 fi
27282 27282
27283 27283
27284 27284 if test "x$path" != "x$new_path"; then
27285 27285 BOOT_JDK="$new_path"
27286 27286 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27287 27287 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27288 27288 fi
27289 27289
27290 27290 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27291 27291
27292 27292 path="$BOOT_JDK"
27293 27293 has_colon=`$ECHO $path | $GREP ^.:`
27294 27294 new_path="$path"
27295 27295 if test "x$has_colon" = x; then
27296 27296 # Not in mixed or Windows style, start by that.
27297 27297 new_path=`cmd //c echo $path`
27298 27298 fi
27299 27299
27300 27300
27301 27301 input_path="$new_path"
27302 27302 # Check if we need to convert this using DOS-style short mode. If the path
27303 27303 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27304 27304 # take no chances and rewrite it.
27305 27305 # Note: m4 eats our [], so we need to use [ and ] instead.
27306 27306 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
27307 27307 if test "x$has_forbidden_chars" != x; then
27308 27308 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27309 27309 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27310 27310 fi
27311 27311
27312 27312
27313 27313 windows_path="$new_path"
27314 27314 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27315 27315 unix_path=`$CYGPATH -u "$windows_path"`
27316 27316 new_path="$unix_path"
27317 27317 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27318 27318 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27319 27319 new_path="$unix_path"
27320 27320 fi
27321 27321
27322 27322 if test "x$path" != "x$new_path"; then
27323 27323 BOOT_JDK="$new_path"
27324 27324 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27325 27325 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27326 27326 fi
27327 27327
27328 27328 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27329 27329 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27330 27330
27331 27331 else
27332 27332 # We're on a unix platform. Hooray! :)
27333 27333 path="$BOOT_JDK"
27334 27334 has_space=`$ECHO "$path" | $GREP " "`
27335 27335 if test "x$has_space" != x; then
27336 27336 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27337 27337 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27338 27338 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
27339 27339 fi
27340 27340
27341 27341 # Use eval to expand a potential ~
27342 27342 eval path="$path"
27343 27343 if test ! -f "$path" && test ! -d "$path"; then
27344 27344 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
27345 27345 fi
27346 27346
27347 27347 if test -d "$path"; then
27348 27348 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
27349 27349 else
27350 27350 dir="`$DIRNAME "$path"`"
27351 27351 base="`$BASENAME "$path"`"
27352 27352 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
27353 27353 fi
27354 27354 fi
27355 27355 fi
27356 27356
27357 27357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
27358 27358 $as_echo_n "checking for Boot JDK... " >&6; }
27359 27359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27360 27360 $as_echo "$BOOT_JDK" >&6; }
27361 27361 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
27362 27362 $as_echo_n "checking Boot JDK version... " >&6; }
27363 27363 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
27364 27364 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
27365 27365 $as_echo "$BOOT_JDK_VERSION" >&6; }
27366 27366 fi # end check jdk version
27367 27367 fi # end check javac
27368 27368 fi # end check java
27369 27369 fi # end check boot jdk found
27370 27370 fi
27371 27371
27372 27372
27373 27373 if test "x$BOOT_JDK_FOUND" = xno; then
27374 27374 # Now execute the test
27375 27375
27376 27376 if test "x$PROGRAMFILES" != x; then
27377 27377 VIRTUAL_DIR="$PROGRAMFILES/Java"
27378 27378
27379 27379 windows_path="$VIRTUAL_DIR"
27380 27380 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27381 27381 unix_path=`$CYGPATH -u "$windows_path"`
27382 27382 VIRTUAL_DIR="$unix_path"
27383 27383 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27384 27384 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27385 27385 VIRTUAL_DIR="$unix_path"
27386 27386 fi
27387 27387
27388 27388
27389 27389 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
27390 27390 BOOT_JDK_SUFFIX=""
27391 27391 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
27392 27392 if test "x$ALL_JDKS_FOUND" != x; then
27393 27393 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
27394 27394
27395 27395 if test "x$BOOT_JDK_FOUND" = xno; then
27396 27396 # Now execute the test
27397 27397
27398 27398 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
27399 27399 if test -d "$BOOT_JDK"; then
27400 27400 BOOT_JDK_FOUND=maybe
27401 27401 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
27402 27402 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
27403 27403 fi
27404 27404
27405 27405
27406 27406 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27407 27407 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27408 27408 # Do we have a bin/java?
27409 27409 if test ! -x "$BOOT_JDK/bin/java"; then
27410 27410 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27411 27411 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27412 27412 BOOT_JDK_FOUND=no
27413 27413 else
27414 27414 # Do we have a bin/javac?
27415 27415 if test ! -x "$BOOT_JDK/bin/javac"; then
27416 27416 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27417 27417 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27418 27418 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27419 27419 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27420 27420 BOOT_JDK_FOUND=no
27421 27421 else
27422 27422 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
27423 27423 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
27424 27424
27425 27425 # Extra M4 quote needed to protect [] in grep expression.
27426 27426 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
27427 27427 if test "x$FOUND_CORRECT_VERSION" = x; then
27428 27428 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
27429 27429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
27430 27430 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
27431 27431 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
27432 27432 BOOT_JDK_FOUND=no
27433 27433 else
27434 27434 # We're done! :-)
27435 27435 BOOT_JDK_FOUND=yes
27436 27436
27437 27437 # Only process if variable expands to non-empty
27438 27438
27439 27439 if test "x$BOOT_JDK" != x; then
27440 27440 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27441 27441
27442 27442 # Input might be given as Windows format, start by converting to
27443 27443 # unix format.
27444 27444 path="$BOOT_JDK"
27445 27445 new_path=`$CYGPATH -u "$path"`
27446 27446
27447 27447 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
27448 27448 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
27449 27449 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
27450 27450 # "foo.exe" is OK but "foo" is an error.
27451 27451 #
27452 27452 # This test is therefore slightly more accurate than "test -f" to check for file precense.
27453 27453 # It is also a way to make sure we got the proper file name for the real test later on.
27454 27454 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
27455 27455 if test "x$test_shortpath" = x; then
27456 27456 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27457 27457 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27458 27458 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
27459 27459 fi
27460 27460
27461 27461 # Call helper function which possibly converts this using DOS-style short mode.
27462 27462 # If so, the updated path is stored in $new_path.
27463 27463
27464 27464 input_path="$new_path"
27465 27465 # Check if we need to convert this using DOS-style short mode. If the path
27466 27466 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27467 27467 # take no chances and rewrite it.
27468 27468 # Note: m4 eats our [], so we need to use [ and ] instead.
27469 27469 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27470 27470 if test "x$has_forbidden_chars" != x; then
27471 27471 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27472 27472 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27473 27473 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27474 27474 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27475 27475 # Going to short mode and back again did indeed matter. Since short mode is
27476 27476 # case insensitive, let's make it lowercase to improve readability.
27477 27477 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27478 27478 # Now convert it back to Unix-style (cygpath)
27479 27479 input_path=`$CYGPATH -u "$shortmode_path"`
27480 27480 new_path="$input_path"
27481 27481 fi
27482 27482 fi
27483 27483
27484 27484 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27485 27485 if test "x$test_cygdrive_prefix" = x; then
27486 27486 # As a simple fix, exclude /usr/bin since it's not a real path.
27487 27487 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
27488 27488 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27489 27489 # a path prefixed by /cygdrive for fixpath to work.
27490 27490 new_path="$CYGWIN_ROOT_PATH$input_path"
27491 27491 fi
27492 27492 fi
27493 27493
27494 27494
27495 27495 if test "x$path" != "x$new_path"; then
27496 27496 BOOT_JDK="$new_path"
27497 27497 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27498 27498 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27499 27499 fi
27500 27500
27501 27501 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27502 27502
27503 27503 path="$BOOT_JDK"
27504 27504 has_colon=`$ECHO $path | $GREP ^.:`
27505 27505 new_path="$path"
27506 27506 if test "x$has_colon" = x; then
27507 27507 # Not in mixed or Windows style, start by that.
27508 27508 new_path=`cmd //c echo $path`
27509 27509 fi
27510 27510
27511 27511
27512 27512 input_path="$new_path"
27513 27513 # Check if we need to convert this using DOS-style short mode. If the path
27514 27514 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27515 27515 # take no chances and rewrite it.
27516 27516 # Note: m4 eats our [], so we need to use [ and ] instead.
27517 27517 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
27518 27518 if test "x$has_forbidden_chars" != x; then
27519 27519 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27520 27520 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27521 27521 fi
27522 27522
27523 27523
27524 27524 windows_path="$new_path"
27525 27525 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27526 27526 unix_path=`$CYGPATH -u "$windows_path"`
27527 27527 new_path="$unix_path"
27528 27528 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27529 27529 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27530 27530 new_path="$unix_path"
27531 27531 fi
27532 27532
27533 27533 if test "x$path" != "x$new_path"; then
27534 27534 BOOT_JDK="$new_path"
27535 27535 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27536 27536 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27537 27537 fi
27538 27538
27539 27539 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27540 27540 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27541 27541
27542 27542 else
27543 27543 # We're on a unix platform. Hooray! :)
27544 27544 path="$BOOT_JDK"
27545 27545 has_space=`$ECHO "$path" | $GREP " "`
27546 27546 if test "x$has_space" != x; then
27547 27547 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27548 27548 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27549 27549 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
27550 27550 fi
27551 27551
27552 27552 # Use eval to expand a potential ~
27553 27553 eval path="$path"
27554 27554 if test ! -f "$path" && test ! -d "$path"; then
27555 27555 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
27556 27556 fi
27557 27557
27558 27558 if test -d "$path"; then
27559 27559 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
27560 27560 else
27561 27561 dir="`$DIRNAME "$path"`"
27562 27562 base="`$BASENAME "$path"`"
27563 27563 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
27564 27564 fi
27565 27565 fi
27566 27566 fi
27567 27567
27568 27568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
27569 27569 $as_echo_n "checking for Boot JDK... " >&6; }
27570 27570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27571 27571 $as_echo "$BOOT_JDK" >&6; }
27572 27572 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
27573 27573 $as_echo_n "checking Boot JDK version... " >&6; }
27574 27574 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
27575 27575 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
27576 27576 $as_echo "$BOOT_JDK_VERSION" >&6; }
27577 27577 fi # end check jdk version
27578 27578 fi # end check javac
27579 27579 fi # end check java
27580 27580 fi # end check boot jdk found
27581 27581 fi
27582 27582
27583 27583 done
27584 27584 fi
27585 27585
27586 27586 fi
27587 27587
27588 27588
27589 27589 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27590 27590 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27591 27591 # Do we have a bin/java?
27592 27592 if test ! -x "$BOOT_JDK/bin/java"; then
27593 27593 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27594 27594 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27595 27595 BOOT_JDK_FOUND=no
27596 27596 else
27597 27597 # Do we have a bin/javac?
27598 27598 if test ! -x "$BOOT_JDK/bin/javac"; then
27599 27599 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27600 27600 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27601 27601 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27602 27602 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27603 27603 BOOT_JDK_FOUND=no
27604 27604 else
27605 27605 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
27606 27606 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
27607 27607
27608 27608 # Extra M4 quote needed to protect [] in grep expression.
27609 27609 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
27610 27610 if test "x$FOUND_CORRECT_VERSION" = x; then
27611 27611 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
27612 27612 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
27613 27613 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
27614 27614 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
27615 27615 BOOT_JDK_FOUND=no
27616 27616 else
27617 27617 # We're done! :-)
27618 27618 BOOT_JDK_FOUND=yes
27619 27619
27620 27620 # Only process if variable expands to non-empty
27621 27621
27622 27622 if test "x$BOOT_JDK" != x; then
27623 27623 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27624 27624
27625 27625 # Input might be given as Windows format, start by converting to
27626 27626 # unix format.
27627 27627 path="$BOOT_JDK"
27628 27628 new_path=`$CYGPATH -u "$path"`
27629 27629
27630 27630 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
27631 27631 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
27632 27632 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
27633 27633 # "foo.exe" is OK but "foo" is an error.
27634 27634 #
27635 27635 # This test is therefore slightly more accurate than "test -f" to check for file precense.
27636 27636 # It is also a way to make sure we got the proper file name for the real test later on.
27637 27637 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
27638 27638 if test "x$test_shortpath" = x; then
27639 27639 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27640 27640 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27641 27641 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
27642 27642 fi
27643 27643
27644 27644 # Call helper function which possibly converts this using DOS-style short mode.
27645 27645 # If so, the updated path is stored in $new_path.
27646 27646
27647 27647 input_path="$new_path"
27648 27648 # Check if we need to convert this using DOS-style short mode. If the path
27649 27649 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27650 27650 # take no chances and rewrite it.
27651 27651 # Note: m4 eats our [], so we need to use [ and ] instead.
27652 27652 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27653 27653 if test "x$has_forbidden_chars" != x; then
27654 27654 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27655 27655 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27656 27656 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27657 27657 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27658 27658 # Going to short mode and back again did indeed matter. Since short mode is
27659 27659 # case insensitive, let's make it lowercase to improve readability.
27660 27660 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27661 27661 # Now convert it back to Unix-style (cygpath)
27662 27662 input_path=`$CYGPATH -u "$shortmode_path"`
27663 27663 new_path="$input_path"
27664 27664 fi
27665 27665 fi
27666 27666
27667 27667 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27668 27668 if test "x$test_cygdrive_prefix" = x; then
27669 27669 # As a simple fix, exclude /usr/bin since it's not a real path.
27670 27670 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
27671 27671 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27672 27672 # a path prefixed by /cygdrive for fixpath to work.
27673 27673 new_path="$CYGWIN_ROOT_PATH$input_path"
27674 27674 fi
27675 27675 fi
27676 27676
27677 27677
27678 27678 if test "x$path" != "x$new_path"; then
27679 27679 BOOT_JDK="$new_path"
27680 27680 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27681 27681 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27682 27682 fi
27683 27683
27684 27684 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27685 27685
27686 27686 path="$BOOT_JDK"
27687 27687 has_colon=`$ECHO $path | $GREP ^.:`
27688 27688 new_path="$path"
27689 27689 if test "x$has_colon" = x; then
27690 27690 # Not in mixed or Windows style, start by that.
27691 27691 new_path=`cmd //c echo $path`
27692 27692 fi
27693 27693
27694 27694
27695 27695 input_path="$new_path"
27696 27696 # Check if we need to convert this using DOS-style short mode. If the path
27697 27697 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27698 27698 # take no chances and rewrite it.
27699 27699 # Note: m4 eats our [], so we need to use [ and ] instead.
27700 27700 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
27701 27701 if test "x$has_forbidden_chars" != x; then
27702 27702 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27703 27703 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27704 27704 fi
27705 27705
27706 27706
27707 27707 windows_path="$new_path"
27708 27708 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27709 27709 unix_path=`$CYGPATH -u "$windows_path"`
27710 27710 new_path="$unix_path"
27711 27711 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27712 27712 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27713 27713 new_path="$unix_path"
27714 27714 fi
27715 27715
27716 27716 if test "x$path" != "x$new_path"; then
27717 27717 BOOT_JDK="$new_path"
27718 27718 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27719 27719 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27720 27720 fi
27721 27721
27722 27722 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27723 27723 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27724 27724
27725 27725 else
27726 27726 # We're on a unix platform. Hooray! :)
27727 27727 path="$BOOT_JDK"
27728 27728 has_space=`$ECHO "$path" | $GREP " "`
27729 27729 if test "x$has_space" != x; then
27730 27730 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27731 27731 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27732 27732 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
27733 27733 fi
27734 27734
27735 27735 # Use eval to expand a potential ~
27736 27736 eval path="$path"
27737 27737 if test ! -f "$path" && test ! -d "$path"; then
27738 27738 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
27739 27739 fi
27740 27740
27741 27741 if test -d "$path"; then
27742 27742 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
27743 27743 else
27744 27744 dir="`$DIRNAME "$path"`"
27745 27745 base="`$BASENAME "$path"`"
27746 27746 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
27747 27747 fi
27748 27748 fi
27749 27749 fi
27750 27750
27751 27751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
27752 27752 $as_echo_n "checking for Boot JDK... " >&6; }
27753 27753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27754 27754 $as_echo "$BOOT_JDK" >&6; }
27755 27755 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
27756 27756 $as_echo_n "checking Boot JDK version... " >&6; }
27757 27757 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
27758 27758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
27759 27759 $as_echo "$BOOT_JDK_VERSION" >&6; }
27760 27760 fi # end check jdk version
27761 27761 fi # end check javac
27762 27762 fi # end check java
27763 27763 fi # end check boot jdk found
27764 27764 fi
27765 27765
27766 27766
27767 27767 if test "x$BOOT_JDK_FOUND" = xno; then
27768 27768 # Now execute the test
27769 27769
27770 27770 if test "x$ProgramFiles" != x; then
27771 27771 VIRTUAL_DIR="$ProgramFiles/Java"
27772 27772
27773 27773 windows_path="$VIRTUAL_DIR"
27774 27774 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27775 27775 unix_path=`$CYGPATH -u "$windows_path"`
27776 27776 VIRTUAL_DIR="$unix_path"
27777 27777 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27778 27778 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27779 27779 VIRTUAL_DIR="$unix_path"
27780 27780 fi
27781 27781
27782 27782
27783 27783 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
27784 27784 BOOT_JDK_SUFFIX=""
27785 27785 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
27786 27786 if test "x$ALL_JDKS_FOUND" != x; then
27787 27787 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
27788 27788
27789 27789 if test "x$BOOT_JDK_FOUND" = xno; then
27790 27790 # Now execute the test
27791 27791
27792 27792 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
27793 27793 if test -d "$BOOT_JDK"; then
27794 27794 BOOT_JDK_FOUND=maybe
27795 27795 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
27796 27796 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
27797 27797 fi
27798 27798
27799 27799
27800 27800 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27801 27801 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27802 27802 # Do we have a bin/java?
27803 27803 if test ! -x "$BOOT_JDK/bin/java"; then
27804 27804 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27805 27805 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27806 27806 BOOT_JDK_FOUND=no
27807 27807 else
27808 27808 # Do we have a bin/javac?
27809 27809 if test ! -x "$BOOT_JDK/bin/javac"; then
27810 27810 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27811 27811 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27812 27812 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27813 27813 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27814 27814 BOOT_JDK_FOUND=no
27815 27815 else
27816 27816 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
27817 27817 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
27818 27818
27819 27819 # Extra M4 quote needed to protect [] in grep expression.
27820 27820 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
27821 27821 if test "x$FOUND_CORRECT_VERSION" = x; then
27822 27822 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
27823 27823 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
27824 27824 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
27825 27825 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
27826 27826 BOOT_JDK_FOUND=no
27827 27827 else
27828 27828 # We're done! :-)
27829 27829 BOOT_JDK_FOUND=yes
27830 27830
27831 27831 # Only process if variable expands to non-empty
27832 27832
27833 27833 if test "x$BOOT_JDK" != x; then
27834 27834 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27835 27835
27836 27836 # Input might be given as Windows format, start by converting to
27837 27837 # unix format.
27838 27838 path="$BOOT_JDK"
27839 27839 new_path=`$CYGPATH -u "$path"`
27840 27840
27841 27841 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
27842 27842 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
27843 27843 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
27844 27844 # "foo.exe" is OK but "foo" is an error.
27845 27845 #
27846 27846 # This test is therefore slightly more accurate than "test -f" to check for file precense.
27847 27847 # It is also a way to make sure we got the proper file name for the real test later on.
27848 27848 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
27849 27849 if test "x$test_shortpath" = x; then
27850 27850 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27851 27851 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27852 27852 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
27853 27853 fi
27854 27854
27855 27855 # Call helper function which possibly converts this using DOS-style short mode.
27856 27856 # If so, the updated path is stored in $new_path.
27857 27857
27858 27858 input_path="$new_path"
27859 27859 # Check if we need to convert this using DOS-style short mode. If the path
27860 27860 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27861 27861 # take no chances and rewrite it.
27862 27862 # Note: m4 eats our [], so we need to use [ and ] instead.
27863 27863 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27864 27864 if test "x$has_forbidden_chars" != x; then
27865 27865 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27866 27866 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27867 27867 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27868 27868 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27869 27869 # Going to short mode and back again did indeed matter. Since short mode is
27870 27870 # case insensitive, let's make it lowercase to improve readability.
27871 27871 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27872 27872 # Now convert it back to Unix-style (cygpath)
27873 27873 input_path=`$CYGPATH -u "$shortmode_path"`
27874 27874 new_path="$input_path"
27875 27875 fi
27876 27876 fi
27877 27877
27878 27878 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27879 27879 if test "x$test_cygdrive_prefix" = x; then
27880 27880 # As a simple fix, exclude /usr/bin since it's not a real path.
27881 27881 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
27882 27882 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27883 27883 # a path prefixed by /cygdrive for fixpath to work.
27884 27884 new_path="$CYGWIN_ROOT_PATH$input_path"
27885 27885 fi
27886 27886 fi
27887 27887
27888 27888
27889 27889 if test "x$path" != "x$new_path"; then
27890 27890 BOOT_JDK="$new_path"
27891 27891 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27892 27892 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27893 27893 fi
27894 27894
27895 27895 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27896 27896
27897 27897 path="$BOOT_JDK"
27898 27898 has_colon=`$ECHO $path | $GREP ^.:`
27899 27899 new_path="$path"
27900 27900 if test "x$has_colon" = x; then
27901 27901 # Not in mixed or Windows style, start by that.
27902 27902 new_path=`cmd //c echo $path`
27903 27903 fi
27904 27904
27905 27905
27906 27906 input_path="$new_path"
27907 27907 # Check if we need to convert this using DOS-style short mode. If the path
27908 27908 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27909 27909 # take no chances and rewrite it.
27910 27910 # Note: m4 eats our [], so we need to use [ and ] instead.
27911 27911 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
27912 27912 if test "x$has_forbidden_chars" != x; then
27913 27913 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27914 27914 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27915 27915 fi
27916 27916
27917 27917
27918 27918 windows_path="$new_path"
27919 27919 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27920 27920 unix_path=`$CYGPATH -u "$windows_path"`
27921 27921 new_path="$unix_path"
27922 27922 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27923 27923 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27924 27924 new_path="$unix_path"
27925 27925 fi
27926 27926
27927 27927 if test "x$path" != "x$new_path"; then
27928 27928 BOOT_JDK="$new_path"
27929 27929 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
27930 27930 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
27931 27931 fi
27932 27932
27933 27933 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27934 27934 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27935 27935
27936 27936 else
27937 27937 # We're on a unix platform. Hooray! :)
27938 27938 path="$BOOT_JDK"
27939 27939 has_space=`$ECHO "$path" | $GREP " "`
27940 27940 if test "x$has_space" != x; then
27941 27941 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
27942 27942 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
27943 27943 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
27944 27944 fi
27945 27945
27946 27946 # Use eval to expand a potential ~
27947 27947 eval path="$path"
27948 27948 if test ! -f "$path" && test ! -d "$path"; then
27949 27949 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
27950 27950 fi
27951 27951
27952 27952 if test -d "$path"; then
27953 27953 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
27954 27954 else
27955 27955 dir="`$DIRNAME "$path"`"
27956 27956 base="`$BASENAME "$path"`"
27957 27957 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
27958 27958 fi
27959 27959 fi
27960 27960 fi
27961 27961
27962 27962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
27963 27963 $as_echo_n "checking for Boot JDK... " >&6; }
27964 27964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27965 27965 $as_echo "$BOOT_JDK" >&6; }
27966 27966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
27967 27967 $as_echo_n "checking Boot JDK version... " >&6; }
27968 27968 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
27969 27969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
27970 27970 $as_echo "$BOOT_JDK_VERSION" >&6; }
27971 27971 fi # end check jdk version
27972 27972 fi # end check javac
27973 27973 fi # end check java
27974 27974 fi # end check boot jdk found
27975 27975 fi
27976 27976
27977 27977 done
27978 27978 fi
27979 27979
27980 27980 fi
27981 27981
27982 27982
27983 27983 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
27984 27984 if test "x$BOOT_JDK_FOUND" = xmaybe; then
27985 27985 # Do we have a bin/java?
27986 27986 if test ! -x "$BOOT_JDK/bin/java"; then
27987 27987 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
27988 27988 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
27989 27989 BOOT_JDK_FOUND=no
27990 27990 else
27991 27991 # Do we have a bin/javac?
27992 27992 if test ! -x "$BOOT_JDK/bin/javac"; then
27993 27993 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
27994 27994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
27995 27995 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
27996 27996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
27997 27997 BOOT_JDK_FOUND=no
27998 27998 else
27999 27999 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28000 28000 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28001 28001
28002 28002 # Extra M4 quote needed to protect [] in grep expression.
28003 28003 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28004 28004 if test "x$FOUND_CORRECT_VERSION" = x; then
28005 28005 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28006 28006 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28007 28007 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28008 28008 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28009 28009 BOOT_JDK_FOUND=no
28010 28010 else
28011 28011 # We're done! :-)
28012 28012 BOOT_JDK_FOUND=yes
28013 28013
28014 28014 # Only process if variable expands to non-empty
28015 28015
28016 28016 if test "x$BOOT_JDK" != x; then
28017 28017 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28018 28018
28019 28019 # Input might be given as Windows format, start by converting to
28020 28020 # unix format.
28021 28021 path="$BOOT_JDK"
28022 28022 new_path=`$CYGPATH -u "$path"`
28023 28023
28024 28024 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28025 28025 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28026 28026 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28027 28027 # "foo.exe" is OK but "foo" is an error.
28028 28028 #
28029 28029 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28030 28030 # It is also a way to make sure we got the proper file name for the real test later on.
28031 28031 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28032 28032 if test "x$test_shortpath" = x; then
28033 28033 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28034 28034 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28035 28035 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28036 28036 fi
28037 28037
28038 28038 # Call helper function which possibly converts this using DOS-style short mode.
28039 28039 # If so, the updated path is stored in $new_path.
28040 28040
28041 28041 input_path="$new_path"
28042 28042 # Check if we need to convert this using DOS-style short mode. If the path
28043 28043 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28044 28044 # take no chances and rewrite it.
28045 28045 # Note: m4 eats our [], so we need to use [ and ] instead.
28046 28046 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28047 28047 if test "x$has_forbidden_chars" != x; then
28048 28048 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28049 28049 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28050 28050 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28051 28051 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28052 28052 # Going to short mode and back again did indeed matter. Since short mode is
28053 28053 # case insensitive, let's make it lowercase to improve readability.
28054 28054 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28055 28055 # Now convert it back to Unix-style (cygpath)
28056 28056 input_path=`$CYGPATH -u "$shortmode_path"`
28057 28057 new_path="$input_path"
28058 28058 fi
28059 28059 fi
28060 28060
28061 28061 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28062 28062 if test "x$test_cygdrive_prefix" = x; then
28063 28063 # As a simple fix, exclude /usr/bin since it's not a real path.
28064 28064 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
28065 28065 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28066 28066 # a path prefixed by /cygdrive for fixpath to work.
28067 28067 new_path="$CYGWIN_ROOT_PATH$input_path"
28068 28068 fi
28069 28069 fi
28070 28070
28071 28071
28072 28072 if test "x$path" != "x$new_path"; then
28073 28073 BOOT_JDK="$new_path"
28074 28074 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28075 28075 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28076 28076 fi
28077 28077
28078 28078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28079 28079
28080 28080 path="$BOOT_JDK"
28081 28081 has_colon=`$ECHO $path | $GREP ^.:`
28082 28082 new_path="$path"
28083 28083 if test "x$has_colon" = x; then
28084 28084 # Not in mixed or Windows style, start by that.
28085 28085 new_path=`cmd //c echo $path`
28086 28086 fi
28087 28087
28088 28088
28089 28089 input_path="$new_path"
28090 28090 # Check if we need to convert this using DOS-style short mode. If the path
28091 28091 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28092 28092 # take no chances and rewrite it.
28093 28093 # Note: m4 eats our [], so we need to use [ and ] instead.
28094 28094 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
28095 28095 if test "x$has_forbidden_chars" != x; then
28096 28096 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28097 28097 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28098 28098 fi
28099 28099
28100 28100
28101 28101 windows_path="$new_path"
28102 28102 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28103 28103 unix_path=`$CYGPATH -u "$windows_path"`
28104 28104 new_path="$unix_path"
28105 28105 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28106 28106 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28107 28107 new_path="$unix_path"
28108 28108 fi
28109 28109
28110 28110 if test "x$path" != "x$new_path"; then
28111 28111 BOOT_JDK="$new_path"
28112 28112 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28113 28113 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28114 28114 fi
28115 28115
28116 28116 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28117 28117 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28118 28118
28119 28119 else
28120 28120 # We're on a unix platform. Hooray! :)
28121 28121 path="$BOOT_JDK"
28122 28122 has_space=`$ECHO "$path" | $GREP " "`
28123 28123 if test "x$has_space" != x; then
28124 28124 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28125 28125 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28126 28126 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
28127 28127 fi
28128 28128
28129 28129 # Use eval to expand a potential ~
28130 28130 eval path="$path"
28131 28131 if test ! -f "$path" && test ! -d "$path"; then
28132 28132 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
28133 28133 fi
28134 28134
28135 28135 if test -d "$path"; then
28136 28136 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
28137 28137 else
28138 28138 dir="`$DIRNAME "$path"`"
28139 28139 base="`$BASENAME "$path"`"
28140 28140 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
28141 28141 fi
28142 28142 fi
28143 28143 fi
28144 28144
28145 28145 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
28146 28146 $as_echo_n "checking for Boot JDK... " >&6; }
28147 28147 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
28148 28148 $as_echo "$BOOT_JDK" >&6; }
28149 28149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
28150 28150 $as_echo_n "checking Boot JDK version... " >&6; }
28151 28151 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
28152 28152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
28153 28153 $as_echo "$BOOT_JDK_VERSION" >&6; }
28154 28154 fi # end check jdk version
28155 28155 fi # end check javac
28156 28156 fi # end check java
28157 28157 fi # end check boot jdk found
28158 28158 fi
28159 28159
28160 28160
28161 28161 if test "x$BOOT_JDK_FOUND" = xno; then
28162 28162 # Now execute the test
28163 28163
28164 28164 BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
28165 28165 BOOT_JDK_SUFFIX=""
28166 28166 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
28167 28167 if test "x$ALL_JDKS_FOUND" != x; then
28168 28168 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
28169 28169
28170 28170 if test "x$BOOT_JDK_FOUND" = xno; then
28171 28171 # Now execute the test
28172 28172
28173 28173 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
28174 28174 if test -d "$BOOT_JDK"; then
28175 28175 BOOT_JDK_FOUND=maybe
28176 28176 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
28177 28177 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
28178 28178 fi
28179 28179
28180 28180
28181 28181 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
28182 28182 if test "x$BOOT_JDK_FOUND" = xmaybe; then
28183 28183 # Do we have a bin/java?
28184 28184 if test ! -x "$BOOT_JDK/bin/java"; then
28185 28185 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
28186 28186 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
28187 28187 BOOT_JDK_FOUND=no
28188 28188 else
28189 28189 # Do we have a bin/javac?
28190 28190 if test ! -x "$BOOT_JDK/bin/javac"; then
28191 28191 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
28192 28192 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
28193 28193 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
28194 28194 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
28195 28195 BOOT_JDK_FOUND=no
28196 28196 else
28197 28197 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28198 28198 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28199 28199
28200 28200 # Extra M4 quote needed to protect [] in grep expression.
28201 28201 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28202 28202 if test "x$FOUND_CORRECT_VERSION" = x; then
28203 28203 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28204 28204 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28205 28205 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28206 28206 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28207 28207 BOOT_JDK_FOUND=no
28208 28208 else
28209 28209 # We're done! :-)
28210 28210 BOOT_JDK_FOUND=yes
28211 28211
28212 28212 # Only process if variable expands to non-empty
28213 28213
28214 28214 if test "x$BOOT_JDK" != x; then
28215 28215 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28216 28216
28217 28217 # Input might be given as Windows format, start by converting to
28218 28218 # unix format.
28219 28219 path="$BOOT_JDK"
28220 28220 new_path=`$CYGPATH -u "$path"`
28221 28221
28222 28222 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28223 28223 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28224 28224 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28225 28225 # "foo.exe" is OK but "foo" is an error.
28226 28226 #
28227 28227 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28228 28228 # It is also a way to make sure we got the proper file name for the real test later on.
28229 28229 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28230 28230 if test "x$test_shortpath" = x; then
28231 28231 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28232 28232 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28233 28233 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28234 28234 fi
28235 28235
28236 28236 # Call helper function which possibly converts this using DOS-style short mode.
28237 28237 # If so, the updated path is stored in $new_path.
28238 28238
28239 28239 input_path="$new_path"
28240 28240 # Check if we need to convert this using DOS-style short mode. If the path
28241 28241 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28242 28242 # take no chances and rewrite it.
28243 28243 # Note: m4 eats our [], so we need to use [ and ] instead.
28244 28244 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28245 28245 if test "x$has_forbidden_chars" != x; then
28246 28246 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28247 28247 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28248 28248 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28249 28249 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28250 28250 # Going to short mode and back again did indeed matter. Since short mode is
28251 28251 # case insensitive, let's make it lowercase to improve readability.
28252 28252 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28253 28253 # Now convert it back to Unix-style (cygpath)
28254 28254 input_path=`$CYGPATH -u "$shortmode_path"`
28255 28255 new_path="$input_path"
28256 28256 fi
28257 28257 fi
28258 28258
28259 28259 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28260 28260 if test "x$test_cygdrive_prefix" = x; then
28261 28261 # As a simple fix, exclude /usr/bin since it's not a real path.
28262 28262 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
28263 28263 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28264 28264 # a path prefixed by /cygdrive for fixpath to work.
28265 28265 new_path="$CYGWIN_ROOT_PATH$input_path"
28266 28266 fi
28267 28267 fi
28268 28268
28269 28269
28270 28270 if test "x$path" != "x$new_path"; then
28271 28271 BOOT_JDK="$new_path"
28272 28272 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28273 28273 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28274 28274 fi
28275 28275
28276 28276 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28277 28277
28278 28278 path="$BOOT_JDK"
28279 28279 has_colon=`$ECHO $path | $GREP ^.:`
28280 28280 new_path="$path"
28281 28281 if test "x$has_colon" = x; then
28282 28282 # Not in mixed or Windows style, start by that.
28283 28283 new_path=`cmd //c echo $path`
28284 28284 fi
28285 28285
28286 28286
28287 28287 input_path="$new_path"
28288 28288 # Check if we need to convert this using DOS-style short mode. If the path
28289 28289 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28290 28290 # take no chances and rewrite it.
28291 28291 # Note: m4 eats our [], so we need to use [ and ] instead.
28292 28292 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
28293 28293 if test "x$has_forbidden_chars" != x; then
28294 28294 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28295 28295 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28296 28296 fi
28297 28297
28298 28298
28299 28299 windows_path="$new_path"
28300 28300 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28301 28301 unix_path=`$CYGPATH -u "$windows_path"`
28302 28302 new_path="$unix_path"
28303 28303 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28304 28304 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28305 28305 new_path="$unix_path"
28306 28306 fi
28307 28307
28308 28308 if test "x$path" != "x$new_path"; then
28309 28309 BOOT_JDK="$new_path"
28310 28310 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28311 28311 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28312 28312 fi
28313 28313
28314 28314 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28315 28315 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28316 28316
28317 28317 else
28318 28318 # We're on a unix platform. Hooray! :)
28319 28319 path="$BOOT_JDK"
28320 28320 has_space=`$ECHO "$path" | $GREP " "`
28321 28321 if test "x$has_space" != x; then
28322 28322 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28323 28323 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28324 28324 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
28325 28325 fi
28326 28326
28327 28327 # Use eval to expand a potential ~
28328 28328 eval path="$path"
28329 28329 if test ! -f "$path" && test ! -d "$path"; then
28330 28330 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
28331 28331 fi
28332 28332
28333 28333 if test -d "$path"; then
28334 28334 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
28335 28335 else
28336 28336 dir="`$DIRNAME "$path"`"
28337 28337 base="`$BASENAME "$path"`"
28338 28338 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
28339 28339 fi
28340 28340 fi
28341 28341 fi
28342 28342
28343 28343 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
28344 28344 $as_echo_n "checking for Boot JDK... " >&6; }
28345 28345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
28346 28346 $as_echo "$BOOT_JDK" >&6; }
28347 28347 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
28348 28348 $as_echo_n "checking Boot JDK version... " >&6; }
28349 28349 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
28350 28350 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
28351 28351 $as_echo "$BOOT_JDK_VERSION" >&6; }
28352 28352 fi # end check jdk version
28353 28353 fi # end check javac
28354 28354 fi # end check java
28355 28355 fi # end check boot jdk found
28356 28356 fi
28357 28357
28358 28358 done
28359 28359 fi
28360 28360
28361 28361
28362 28362 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
28363 28363 if test "x$BOOT_JDK_FOUND" = xmaybe; then
28364 28364 # Do we have a bin/java?
28365 28365 if test ! -x "$BOOT_JDK/bin/java"; then
28366 28366 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
28367 28367 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
28368 28368 BOOT_JDK_FOUND=no
28369 28369 else
28370 28370 # Do we have a bin/javac?
28371 28371 if test ! -x "$BOOT_JDK/bin/javac"; then
28372 28372 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
28373 28373 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
28374 28374 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
28375 28375 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
28376 28376 BOOT_JDK_FOUND=no
28377 28377 else
28378 28378 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28379 28379 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28380 28380
28381 28381 # Extra M4 quote needed to protect [] in grep expression.
28382 28382 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28383 28383 if test "x$FOUND_CORRECT_VERSION" = x; then
28384 28384 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28385 28385 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28386 28386 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28387 28387 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28388 28388 BOOT_JDK_FOUND=no
28389 28389 else
28390 28390 # We're done! :-)
28391 28391 BOOT_JDK_FOUND=yes
28392 28392
28393 28393 # Only process if variable expands to non-empty
28394 28394
28395 28395 if test "x$BOOT_JDK" != x; then
28396 28396 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28397 28397
28398 28398 # Input might be given as Windows format, start by converting to
28399 28399 # unix format.
28400 28400 path="$BOOT_JDK"
28401 28401 new_path=`$CYGPATH -u "$path"`
28402 28402
28403 28403 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28404 28404 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28405 28405 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28406 28406 # "foo.exe" is OK but "foo" is an error.
28407 28407 #
28408 28408 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28409 28409 # It is also a way to make sure we got the proper file name for the real test later on.
28410 28410 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28411 28411 if test "x$test_shortpath" = x; then
28412 28412 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28413 28413 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28414 28414 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28415 28415 fi
28416 28416
28417 28417 # Call helper function which possibly converts this using DOS-style short mode.
28418 28418 # If so, the updated path is stored in $new_path.
28419 28419
28420 28420 input_path="$new_path"
28421 28421 # Check if we need to convert this using DOS-style short mode. If the path
28422 28422 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28423 28423 # take no chances and rewrite it.
28424 28424 # Note: m4 eats our [], so we need to use [ and ] instead.
28425 28425 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28426 28426 if test "x$has_forbidden_chars" != x; then
28427 28427 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28428 28428 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28429 28429 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28430 28430 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28431 28431 # Going to short mode and back again did indeed matter. Since short mode is
28432 28432 # case insensitive, let's make it lowercase to improve readability.
28433 28433 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28434 28434 # Now convert it back to Unix-style (cygpath)
28435 28435 input_path=`$CYGPATH -u "$shortmode_path"`
28436 28436 new_path="$input_path"
28437 28437 fi
28438 28438 fi
28439 28439
28440 28440 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28441 28441 if test "x$test_cygdrive_prefix" = x; then
28442 28442 # As a simple fix, exclude /usr/bin since it's not a real path.
28443 28443 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
28444 28444 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28445 28445 # a path prefixed by /cygdrive for fixpath to work.
28446 28446 new_path="$CYGWIN_ROOT_PATH$input_path"
28447 28447 fi
28448 28448 fi
28449 28449
28450 28450
28451 28451 if test "x$path" != "x$new_path"; then
28452 28452 BOOT_JDK="$new_path"
28453 28453 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28454 28454 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28455 28455 fi
28456 28456
28457 28457 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28458 28458
28459 28459 path="$BOOT_JDK"
28460 28460 has_colon=`$ECHO $path | $GREP ^.:`
28461 28461 new_path="$path"
28462 28462 if test "x$has_colon" = x; then
28463 28463 # Not in mixed or Windows style, start by that.
28464 28464 new_path=`cmd //c echo $path`
28465 28465 fi
28466 28466
28467 28467
28468 28468 input_path="$new_path"
28469 28469 # Check if we need to convert this using DOS-style short mode. If the path
28470 28470 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28471 28471 # take no chances and rewrite it.
28472 28472 # Note: m4 eats our [], so we need to use [ and ] instead.
28473 28473 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
28474 28474 if test "x$has_forbidden_chars" != x; then
28475 28475 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28476 28476 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28477 28477 fi
28478 28478
28479 28479
28480 28480 windows_path="$new_path"
28481 28481 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28482 28482 unix_path=`$CYGPATH -u "$windows_path"`
28483 28483 new_path="$unix_path"
28484 28484 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28485 28485 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28486 28486 new_path="$unix_path"
28487 28487 fi
28488 28488
28489 28489 if test "x$path" != "x$new_path"; then
28490 28490 BOOT_JDK="$new_path"
28491 28491 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28492 28492 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28493 28493 fi
28494 28494
28495 28495 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28496 28496 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28497 28497
28498 28498 else
28499 28499 # We're on a unix platform. Hooray! :)
28500 28500 path="$BOOT_JDK"
28501 28501 has_space=`$ECHO "$path" | $GREP " "`
28502 28502 if test "x$has_space" != x; then
28503 28503 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28504 28504 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28505 28505 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
28506 28506 fi
28507 28507
28508 28508 # Use eval to expand a potential ~
28509 28509 eval path="$path"
28510 28510 if test ! -f "$path" && test ! -d "$path"; then
28511 28511 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
28512 28512 fi
28513 28513
28514 28514 if test -d "$path"; then
28515 28515 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
28516 28516 else
28517 28517 dir="`$DIRNAME "$path"`"
28518 28518 base="`$BASENAME "$path"`"
28519 28519 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
28520 28520 fi
28521 28521 fi
28522 28522 fi
28523 28523
28524 28524 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
28525 28525 $as_echo_n "checking for Boot JDK... " >&6; }
28526 28526 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
28527 28527 $as_echo "$BOOT_JDK" >&6; }
28528 28528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
28529 28529 $as_echo_n "checking Boot JDK version... " >&6; }
28530 28530 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
28531 28531 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
28532 28532 $as_echo "$BOOT_JDK_VERSION" >&6; }
28533 28533 fi # end check jdk version
28534 28534 fi # end check javac
28535 28535 fi # end check java
28536 28536 fi # end check boot jdk found
28537 28537 fi
28538 28538
28539 28539 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
28540 28540
28541 28541 if test "x$BOOT_JDK_FOUND" = xno; then
28542 28542 # Now execute the test
28543 28543
28544 28544 BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
28545 28545 BOOT_JDK_SUFFIX="/Contents/Home"
28546 28546 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
28547 28547 if test "x$ALL_JDKS_FOUND" != x; then
28548 28548 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
28549 28549
28550 28550 if test "x$BOOT_JDK_FOUND" = xno; then
28551 28551 # Now execute the test
28552 28552
28553 28553 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
28554 28554 if test -d "$BOOT_JDK"; then
28555 28555 BOOT_JDK_FOUND=maybe
28556 28556 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
28557 28557 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
28558 28558 fi
28559 28559
28560 28560
28561 28561 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
28562 28562 if test "x$BOOT_JDK_FOUND" = xmaybe; then
28563 28563 # Do we have a bin/java?
28564 28564 if test ! -x "$BOOT_JDK/bin/java"; then
28565 28565 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
28566 28566 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
28567 28567 BOOT_JDK_FOUND=no
28568 28568 else
28569 28569 # Do we have a bin/javac?
28570 28570 if test ! -x "$BOOT_JDK/bin/javac"; then
28571 28571 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
28572 28572 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
28573 28573 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
28574 28574 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
28575 28575 BOOT_JDK_FOUND=no
28576 28576 else
28577 28577 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28578 28578 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28579 28579
28580 28580 # Extra M4 quote needed to protect [] in grep expression.
28581 28581 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28582 28582 if test "x$FOUND_CORRECT_VERSION" = x; then
28583 28583 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28584 28584 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28585 28585 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28586 28586 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28587 28587 BOOT_JDK_FOUND=no
28588 28588 else
28589 28589 # We're done! :-)
28590 28590 BOOT_JDK_FOUND=yes
28591 28591
28592 28592 # Only process if variable expands to non-empty
28593 28593
28594 28594 if test "x$BOOT_JDK" != x; then
28595 28595 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28596 28596
28597 28597 # Input might be given as Windows format, start by converting to
28598 28598 # unix format.
28599 28599 path="$BOOT_JDK"
28600 28600 new_path=`$CYGPATH -u "$path"`
28601 28601
28602 28602 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28603 28603 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28604 28604 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28605 28605 # "foo.exe" is OK but "foo" is an error.
28606 28606 #
28607 28607 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28608 28608 # It is also a way to make sure we got the proper file name for the real test later on.
28609 28609 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28610 28610 if test "x$test_shortpath" = x; then
28611 28611 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28612 28612 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28613 28613 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28614 28614 fi
28615 28615
28616 28616 # Call helper function which possibly converts this using DOS-style short mode.
28617 28617 # If so, the updated path is stored in $new_path.
28618 28618
28619 28619 input_path="$new_path"
28620 28620 # Check if we need to convert this using DOS-style short mode. If the path
28621 28621 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28622 28622 # take no chances and rewrite it.
28623 28623 # Note: m4 eats our [], so we need to use [ and ] instead.
28624 28624 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28625 28625 if test "x$has_forbidden_chars" != x; then
28626 28626 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28627 28627 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28628 28628 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28629 28629 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28630 28630 # Going to short mode and back again did indeed matter. Since short mode is
28631 28631 # case insensitive, let's make it lowercase to improve readability.
28632 28632 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28633 28633 # Now convert it back to Unix-style (cygpath)
28634 28634 input_path=`$CYGPATH -u "$shortmode_path"`
28635 28635 new_path="$input_path"
28636 28636 fi
28637 28637 fi
28638 28638
28639 28639 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28640 28640 if test "x$test_cygdrive_prefix" = x; then
28641 28641 # As a simple fix, exclude /usr/bin since it's not a real path.
28642 28642 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
28643 28643 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28644 28644 # a path prefixed by /cygdrive for fixpath to work.
28645 28645 new_path="$CYGWIN_ROOT_PATH$input_path"
28646 28646 fi
28647 28647 fi
28648 28648
28649 28649
28650 28650 if test "x$path" != "x$new_path"; then
28651 28651 BOOT_JDK="$new_path"
28652 28652 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28653 28653 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28654 28654 fi
28655 28655
28656 28656 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28657 28657
28658 28658 path="$BOOT_JDK"
28659 28659 has_colon=`$ECHO $path | $GREP ^.:`
28660 28660 new_path="$path"
28661 28661 if test "x$has_colon" = x; then
28662 28662 # Not in mixed or Windows style, start by that.
28663 28663 new_path=`cmd //c echo $path`
28664 28664 fi
28665 28665
28666 28666
28667 28667 input_path="$new_path"
28668 28668 # Check if we need to convert this using DOS-style short mode. If the path
28669 28669 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28670 28670 # take no chances and rewrite it.
28671 28671 # Note: m4 eats our [], so we need to use [ and ] instead.
28672 28672 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
28673 28673 if test "x$has_forbidden_chars" != x; then
28674 28674 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28675 28675 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28676 28676 fi
28677 28677
28678 28678
28679 28679 windows_path="$new_path"
28680 28680 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28681 28681 unix_path=`$CYGPATH -u "$windows_path"`
28682 28682 new_path="$unix_path"
28683 28683 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28684 28684 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28685 28685 new_path="$unix_path"
28686 28686 fi
28687 28687
28688 28688 if test "x$path" != "x$new_path"; then
28689 28689 BOOT_JDK="$new_path"
28690 28690 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28691 28691 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28692 28692 fi
28693 28693
28694 28694 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28695 28695 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28696 28696
28697 28697 else
28698 28698 # We're on a unix platform. Hooray! :)
28699 28699 path="$BOOT_JDK"
28700 28700 has_space=`$ECHO "$path" | $GREP " "`
28701 28701 if test "x$has_space" != x; then
28702 28702 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28703 28703 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28704 28704 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
28705 28705 fi
28706 28706
28707 28707 # Use eval to expand a potential ~
28708 28708 eval path="$path"
28709 28709 if test ! -f "$path" && test ! -d "$path"; then
28710 28710 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
28711 28711 fi
28712 28712
28713 28713 if test -d "$path"; then
28714 28714 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
28715 28715 else
28716 28716 dir="`$DIRNAME "$path"`"
28717 28717 base="`$BASENAME "$path"`"
28718 28718 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
28719 28719 fi
28720 28720 fi
28721 28721 fi
28722 28722
28723 28723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
28724 28724 $as_echo_n "checking for Boot JDK... " >&6; }
28725 28725 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
28726 28726 $as_echo "$BOOT_JDK" >&6; }
28727 28727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
28728 28728 $as_echo_n "checking Boot JDK version... " >&6; }
28729 28729 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
28730 28730 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
28731 28731 $as_echo "$BOOT_JDK_VERSION" >&6; }
28732 28732 fi # end check jdk version
28733 28733 fi # end check javac
28734 28734 fi # end check java
28735 28735 fi # end check boot jdk found
28736 28736 fi
28737 28737
28738 28738 done
28739 28739 fi
28740 28740
28741 28741
28742 28742 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
28743 28743 if test "x$BOOT_JDK_FOUND" = xmaybe; then
28744 28744 # Do we have a bin/java?
28745 28745 if test ! -x "$BOOT_JDK/bin/java"; then
28746 28746 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
28747 28747 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
28748 28748 BOOT_JDK_FOUND=no
28749 28749 else
28750 28750 # Do we have a bin/javac?
28751 28751 if test ! -x "$BOOT_JDK/bin/javac"; then
28752 28752 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
28753 28753 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
28754 28754 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
28755 28755 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
28756 28756 BOOT_JDK_FOUND=no
28757 28757 else
28758 28758 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28759 28759 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28760 28760
28761 28761 # Extra M4 quote needed to protect [] in grep expression.
28762 28762 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28763 28763 if test "x$FOUND_CORRECT_VERSION" = x; then
28764 28764 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28765 28765 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28766 28766 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28767 28767 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28768 28768 BOOT_JDK_FOUND=no
28769 28769 else
28770 28770 # We're done! :-)
28771 28771 BOOT_JDK_FOUND=yes
28772 28772
28773 28773 # Only process if variable expands to non-empty
28774 28774
28775 28775 if test "x$BOOT_JDK" != x; then
28776 28776 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28777 28777
28778 28778 # Input might be given as Windows format, start by converting to
28779 28779 # unix format.
28780 28780 path="$BOOT_JDK"
28781 28781 new_path=`$CYGPATH -u "$path"`
28782 28782
28783 28783 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28784 28784 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28785 28785 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28786 28786 # "foo.exe" is OK but "foo" is an error.
28787 28787 #
28788 28788 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28789 28789 # It is also a way to make sure we got the proper file name for the real test later on.
28790 28790 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28791 28791 if test "x$test_shortpath" = x; then
28792 28792 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28793 28793 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28794 28794 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28795 28795 fi
28796 28796
28797 28797 # Call helper function which possibly converts this using DOS-style short mode.
28798 28798 # If so, the updated path is stored in $new_path.
28799 28799
28800 28800 input_path="$new_path"
28801 28801 # Check if we need to convert this using DOS-style short mode. If the path
28802 28802 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28803 28803 # take no chances and rewrite it.
28804 28804 # Note: m4 eats our [], so we need to use [ and ] instead.
28805 28805 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28806 28806 if test "x$has_forbidden_chars" != x; then
28807 28807 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28808 28808 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28809 28809 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28810 28810 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28811 28811 # Going to short mode and back again did indeed matter. Since short mode is
28812 28812 # case insensitive, let's make it lowercase to improve readability.
28813 28813 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28814 28814 # Now convert it back to Unix-style (cygpath)
28815 28815 input_path=`$CYGPATH -u "$shortmode_path"`
28816 28816 new_path="$input_path"
28817 28817 fi
28818 28818 fi
28819 28819
28820 28820 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28821 28821 if test "x$test_cygdrive_prefix" = x; then
28822 28822 # As a simple fix, exclude /usr/bin since it's not a real path.
28823 28823 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
28824 28824 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28825 28825 # a path prefixed by /cygdrive for fixpath to work.
28826 28826 new_path="$CYGWIN_ROOT_PATH$input_path"
28827 28827 fi
28828 28828 fi
28829 28829
28830 28830
28831 28831 if test "x$path" != "x$new_path"; then
28832 28832 BOOT_JDK="$new_path"
28833 28833 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28834 28834 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28835 28835 fi
28836 28836
28837 28837 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28838 28838
28839 28839 path="$BOOT_JDK"
28840 28840 has_colon=`$ECHO $path | $GREP ^.:`
28841 28841 new_path="$path"
28842 28842 if test "x$has_colon" = x; then
28843 28843 # Not in mixed or Windows style, start by that.
28844 28844 new_path=`cmd //c echo $path`
28845 28845 fi
28846 28846
28847 28847
28848 28848 input_path="$new_path"
28849 28849 # Check if we need to convert this using DOS-style short mode. If the path
28850 28850 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28851 28851 # take no chances and rewrite it.
28852 28852 # Note: m4 eats our [], so we need to use [ and ] instead.
28853 28853 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
28854 28854 if test "x$has_forbidden_chars" != x; then
28855 28855 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28856 28856 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28857 28857 fi
28858 28858
28859 28859
28860 28860 windows_path="$new_path"
28861 28861 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28862 28862 unix_path=`$CYGPATH -u "$windows_path"`
28863 28863 new_path="$unix_path"
28864 28864 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28865 28865 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28866 28866 new_path="$unix_path"
28867 28867 fi
28868 28868
28869 28869 if test "x$path" != "x$new_path"; then
28870 28870 BOOT_JDK="$new_path"
28871 28871 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
28872 28872 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
28873 28873 fi
28874 28874
28875 28875 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28876 28876 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28877 28877
28878 28878 else
28879 28879 # We're on a unix platform. Hooray! :)
28880 28880 path="$BOOT_JDK"
28881 28881 has_space=`$ECHO "$path" | $GREP " "`
28882 28882 if test "x$has_space" != x; then
28883 28883 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28884 28884 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28885 28885 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
28886 28886 fi
28887 28887
28888 28888 # Use eval to expand a potential ~
28889 28889 eval path="$path"
28890 28890 if test ! -f "$path" && test ! -d "$path"; then
28891 28891 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
28892 28892 fi
28893 28893
28894 28894 if test -d "$path"; then
28895 28895 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
28896 28896 else
28897 28897 dir="`$DIRNAME "$path"`"
28898 28898 base="`$BASENAME "$path"`"
28899 28899 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
28900 28900 fi
28901 28901 fi
28902 28902 fi
28903 28903
28904 28904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
28905 28905 $as_echo_n "checking for Boot JDK... " >&6; }
28906 28906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
28907 28907 $as_echo "$BOOT_JDK" >&6; }
28908 28908 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
28909 28909 $as_echo_n "checking Boot JDK version... " >&6; }
28910 28910 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
28911 28911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
28912 28912 $as_echo "$BOOT_JDK_VERSION" >&6; }
28913 28913 fi # end check jdk version
28914 28914 fi # end check javac
28915 28915 fi # end check java
28916 28916 fi # end check boot jdk found
28917 28917 fi
28918 28918
28919 28919
28920 28920 if test "x$BOOT_JDK_FOUND" = xno; then
28921 28921 # Now execute the test
28922 28922
28923 28923 BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
28924 28924 BOOT_JDK_SUFFIX="/Contents/Home"
28925 28925 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
28926 28926 if test "x$ALL_JDKS_FOUND" != x; then
28927 28927 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
28928 28928
28929 28929 if test "x$BOOT_JDK_FOUND" = xno; then
28930 28930 # Now execute the test
28931 28931
28932 28932 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
28933 28933 if test -d "$BOOT_JDK"; then
28934 28934 BOOT_JDK_FOUND=maybe
28935 28935 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
28936 28936 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
28937 28937 fi
28938 28938
28939 28939
28940 28940 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
28941 28941 if test "x$BOOT_JDK_FOUND" = xmaybe; then
28942 28942 # Do we have a bin/java?
28943 28943 if test ! -x "$BOOT_JDK/bin/java"; then
28944 28944 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
28945 28945 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
28946 28946 BOOT_JDK_FOUND=no
28947 28947 else
28948 28948 # Do we have a bin/javac?
28949 28949 if test ! -x "$BOOT_JDK/bin/javac"; then
28950 28950 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
28951 28951 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
28952 28952 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
28953 28953 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
28954 28954 BOOT_JDK_FOUND=no
28955 28955 else
28956 28956 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
28957 28957 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
28958 28958
28959 28959 # Extra M4 quote needed to protect [] in grep expression.
28960 28960 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
28961 28961 if test "x$FOUND_CORRECT_VERSION" = x; then
28962 28962 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
28963 28963 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
28964 28964 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
28965 28965 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
28966 28966 BOOT_JDK_FOUND=no
28967 28967 else
28968 28968 # We're done! :-)
28969 28969 BOOT_JDK_FOUND=yes
28970 28970
28971 28971 # Only process if variable expands to non-empty
28972 28972
28973 28973 if test "x$BOOT_JDK" != x; then
28974 28974 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28975 28975
28976 28976 # Input might be given as Windows format, start by converting to
28977 28977 # unix format.
28978 28978 path="$BOOT_JDK"
28979 28979 new_path=`$CYGPATH -u "$path"`
28980 28980
28981 28981 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
28982 28982 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
28983 28983 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
28984 28984 # "foo.exe" is OK but "foo" is an error.
28985 28985 #
28986 28986 # This test is therefore slightly more accurate than "test -f" to check for file precense.
28987 28987 # It is also a way to make sure we got the proper file name for the real test later on.
28988 28988 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
28989 28989 if test "x$test_shortpath" = x; then
28990 28990 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
28991 28991 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
28992 28992 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
28993 28993 fi
28994 28994
28995 28995 # Call helper function which possibly converts this using DOS-style short mode.
28996 28996 # If so, the updated path is stored in $new_path.
28997 28997
28998 28998 input_path="$new_path"
28999 28999 # Check if we need to convert this using DOS-style short mode. If the path
29000 29000 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29001 29001 # take no chances and rewrite it.
29002 29002 # Note: m4 eats our [], so we need to use [ and ] instead.
29003 29003 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29004 29004 if test "x$has_forbidden_chars" != x; then
29005 29005 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29006 29006 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29007 29007 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29008 29008 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29009 29009 # Going to short mode and back again did indeed matter. Since short mode is
29010 29010 # case insensitive, let's make it lowercase to improve readability.
29011 29011 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29012 29012 # Now convert it back to Unix-style (cygpath)
29013 29013 input_path=`$CYGPATH -u "$shortmode_path"`
29014 29014 new_path="$input_path"
29015 29015 fi
29016 29016 fi
29017 29017
29018 29018 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29019 29019 if test "x$test_cygdrive_prefix" = x; then
29020 29020 # As a simple fix, exclude /usr/bin since it's not a real path.
29021 29021 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
29022 29022 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29023 29023 # a path prefixed by /cygdrive for fixpath to work.
29024 29024 new_path="$CYGWIN_ROOT_PATH$input_path"
29025 29025 fi
29026 29026 fi
29027 29027
29028 29028
29029 29029 if test "x$path" != "x$new_path"; then
29030 29030 BOOT_JDK="$new_path"
29031 29031 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29032 29032 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29033 29033 fi
29034 29034
29035 29035 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29036 29036
29037 29037 path="$BOOT_JDK"
29038 29038 has_colon=`$ECHO $path | $GREP ^.:`
29039 29039 new_path="$path"
29040 29040 if test "x$has_colon" = x; then
29041 29041 # Not in mixed or Windows style, start by that.
29042 29042 new_path=`cmd //c echo $path`
29043 29043 fi
29044 29044
29045 29045
29046 29046 input_path="$new_path"
29047 29047 # Check if we need to convert this using DOS-style short mode. If the path
29048 29048 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29049 29049 # take no chances and rewrite it.
29050 29050 # Note: m4 eats our [], so we need to use [ and ] instead.
29051 29051 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
29052 29052 if test "x$has_forbidden_chars" != x; then
29053 29053 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29054 29054 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29055 29055 fi
29056 29056
29057 29057
29058 29058 windows_path="$new_path"
29059 29059 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29060 29060 unix_path=`$CYGPATH -u "$windows_path"`
29061 29061 new_path="$unix_path"
29062 29062 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29063 29063 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29064 29064 new_path="$unix_path"
29065 29065 fi
29066 29066
29067 29067 if test "x$path" != "x$new_path"; then
29068 29068 BOOT_JDK="$new_path"
29069 29069 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29070 29070 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29071 29071 fi
29072 29072
29073 29073 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29074 29074 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29075 29075
29076 29076 else
29077 29077 # We're on a unix platform. Hooray! :)
29078 29078 path="$BOOT_JDK"
29079 29079 has_space=`$ECHO "$path" | $GREP " "`
29080 29080 if test "x$has_space" != x; then
29081 29081 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29082 29082 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29083 29083 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
29084 29084 fi
29085 29085
29086 29086 # Use eval to expand a potential ~
29087 29087 eval path="$path"
29088 29088 if test ! -f "$path" && test ! -d "$path"; then
29089 29089 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
29090 29090 fi
29091 29091
29092 29092 if test -d "$path"; then
29093 29093 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
29094 29094 else
29095 29095 dir="`$DIRNAME "$path"`"
29096 29096 base="`$BASENAME "$path"`"
29097 29097 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
29098 29098 fi
29099 29099 fi
29100 29100 fi
29101 29101
29102 29102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
29103 29103 $as_echo_n "checking for Boot JDK... " >&6; }
29104 29104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
29105 29105 $as_echo "$BOOT_JDK" >&6; }
29106 29106 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
29107 29107 $as_echo_n "checking Boot JDK version... " >&6; }
29108 29108 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
29109 29109 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
29110 29110 $as_echo "$BOOT_JDK_VERSION" >&6; }
29111 29111 fi # end check jdk version
29112 29112 fi # end check javac
29113 29113 fi # end check java
29114 29114 fi # end check boot jdk found
29115 29115 fi
29116 29116
29117 29117 done
29118 29118 fi
29119 29119
29120 29120
29121 29121 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
29122 29122 if test "x$BOOT_JDK_FOUND" = xmaybe; then
29123 29123 # Do we have a bin/java?
29124 29124 if test ! -x "$BOOT_JDK/bin/java"; then
29125 29125 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
29126 29126 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
29127 29127 BOOT_JDK_FOUND=no
29128 29128 else
29129 29129 # Do we have a bin/javac?
29130 29130 if test ! -x "$BOOT_JDK/bin/javac"; then
29131 29131 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
29132 29132 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
29133 29133 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
29134 29134 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
29135 29135 BOOT_JDK_FOUND=no
29136 29136 else
29137 29137 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
29138 29138 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
29139 29139
29140 29140 # Extra M4 quote needed to protect [] in grep expression.
29141 29141 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
29142 29142 if test "x$FOUND_CORRECT_VERSION" = x; then
29143 29143 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
29144 29144 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
29145 29145 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
29146 29146 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
29147 29147 BOOT_JDK_FOUND=no
29148 29148 else
29149 29149 # We're done! :-)
29150 29150 BOOT_JDK_FOUND=yes
29151 29151
29152 29152 # Only process if variable expands to non-empty
29153 29153
29154 29154 if test "x$BOOT_JDK" != x; then
29155 29155 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29156 29156
29157 29157 # Input might be given as Windows format, start by converting to
29158 29158 # unix format.
29159 29159 path="$BOOT_JDK"
29160 29160 new_path=`$CYGPATH -u "$path"`
29161 29161
29162 29162 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
29163 29163 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
29164 29164 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
29165 29165 # "foo.exe" is OK but "foo" is an error.
29166 29166 #
29167 29167 # This test is therefore slightly more accurate than "test -f" to check for file precense.
29168 29168 # It is also a way to make sure we got the proper file name for the real test later on.
29169 29169 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
29170 29170 if test "x$test_shortpath" = x; then
29171 29171 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29172 29172 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29173 29173 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
29174 29174 fi
29175 29175
29176 29176 # Call helper function which possibly converts this using DOS-style short mode.
29177 29177 # If so, the updated path is stored in $new_path.
29178 29178
29179 29179 input_path="$new_path"
29180 29180 # Check if we need to convert this using DOS-style short mode. If the path
29181 29181 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29182 29182 # take no chances and rewrite it.
29183 29183 # Note: m4 eats our [], so we need to use [ and ] instead.
29184 29184 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29185 29185 if test "x$has_forbidden_chars" != x; then
29186 29186 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29187 29187 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29188 29188 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29189 29189 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29190 29190 # Going to short mode and back again did indeed matter. Since short mode is
29191 29191 # case insensitive, let's make it lowercase to improve readability.
29192 29192 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29193 29193 # Now convert it back to Unix-style (cygpath)
29194 29194 input_path=`$CYGPATH -u "$shortmode_path"`
29195 29195 new_path="$input_path"
29196 29196 fi
29197 29197 fi
29198 29198
29199 29199 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29200 29200 if test "x$test_cygdrive_prefix" = x; then
29201 29201 # As a simple fix, exclude /usr/bin since it's not a real path.
29202 29202 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
29203 29203 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29204 29204 # a path prefixed by /cygdrive for fixpath to work.
29205 29205 new_path="$CYGWIN_ROOT_PATH$input_path"
29206 29206 fi
29207 29207 fi
29208 29208
29209 29209
29210 29210 if test "x$path" != "x$new_path"; then
29211 29211 BOOT_JDK="$new_path"
29212 29212 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29213 29213 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29214 29214 fi
29215 29215
29216 29216 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29217 29217
29218 29218 path="$BOOT_JDK"
29219 29219 has_colon=`$ECHO $path | $GREP ^.:`
29220 29220 new_path="$path"
29221 29221 if test "x$has_colon" = x; then
29222 29222 # Not in mixed or Windows style, start by that.
29223 29223 new_path=`cmd //c echo $path`
29224 29224 fi
29225 29225
29226 29226
29227 29227 input_path="$new_path"
29228 29228 # Check if we need to convert this using DOS-style short mode. If the path
29229 29229 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29230 29230 # take no chances and rewrite it.
29231 29231 # Note: m4 eats our [], so we need to use [ and ] instead.
29232 29232 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
29233 29233 if test "x$has_forbidden_chars" != x; then
29234 29234 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29235 29235 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29236 29236 fi
29237 29237
29238 29238
29239 29239 windows_path="$new_path"
29240 29240 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29241 29241 unix_path=`$CYGPATH -u "$windows_path"`
29242 29242 new_path="$unix_path"
29243 29243 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29244 29244 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29245 29245 new_path="$unix_path"
29246 29246 fi
29247 29247
29248 29248 if test "x$path" != "x$new_path"; then
29249 29249 BOOT_JDK="$new_path"
29250 29250 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29251 29251 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29252 29252 fi
29253 29253
29254 29254 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29255 29255 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29256 29256
29257 29257 else
29258 29258 # We're on a unix platform. Hooray! :)
29259 29259 path="$BOOT_JDK"
29260 29260 has_space=`$ECHO "$path" | $GREP " "`
29261 29261 if test "x$has_space" != x; then
29262 29262 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29263 29263 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29264 29264 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
29265 29265 fi
29266 29266
29267 29267 # Use eval to expand a potential ~
29268 29268 eval path="$path"
29269 29269 if test ! -f "$path" && test ! -d "$path"; then
29270 29270 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
29271 29271 fi
29272 29272
29273 29273 if test -d "$path"; then
29274 29274 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
29275 29275 else
29276 29276 dir="`$DIRNAME "$path"`"
29277 29277 base="`$BASENAME "$path"`"
29278 29278 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
29279 29279 fi
29280 29280 fi
29281 29281 fi
29282 29282
29283 29283 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
29284 29284 $as_echo_n "checking for Boot JDK... " >&6; }
29285 29285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
29286 29286 $as_echo "$BOOT_JDK" >&6; }
29287 29287 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
29288 29288 $as_echo_n "checking Boot JDK version... " >&6; }
29289 29289 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
29290 29290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
29291 29291 $as_echo "$BOOT_JDK_VERSION" >&6; }
29292 29292 fi # end check jdk version
29293 29293 fi # end check javac
29294 29294 fi # end check java
29295 29295 fi # end check boot jdk found
29296 29296 fi
29297 29297
29298 29298 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
29299 29299
29300 29300 if test "x$BOOT_JDK_FOUND" = xno; then
29301 29301 # Now execute the test
29302 29302
29303 29303 BOOT_JDK_PREFIX="/usr/lib/jvm"
29304 29304 BOOT_JDK_SUFFIX=""
29305 29305 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
29306 29306 if test "x$ALL_JDKS_FOUND" != x; then
29307 29307 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
29308 29308
29309 29309 if test "x$BOOT_JDK_FOUND" = xno; then
29310 29310 # Now execute the test
29311 29311
29312 29312 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
29313 29313 if test -d "$BOOT_JDK"; then
29314 29314 BOOT_JDK_FOUND=maybe
29315 29315 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
29316 29316 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
29317 29317 fi
29318 29318
29319 29319
29320 29320 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
29321 29321 if test "x$BOOT_JDK_FOUND" = xmaybe; then
29322 29322 # Do we have a bin/java?
29323 29323 if test ! -x "$BOOT_JDK/bin/java"; then
29324 29324 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
29325 29325 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
29326 29326 BOOT_JDK_FOUND=no
29327 29327 else
29328 29328 # Do we have a bin/javac?
29329 29329 if test ! -x "$BOOT_JDK/bin/javac"; then
29330 29330 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
29331 29331 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
29332 29332 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
29333 29333 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
29334 29334 BOOT_JDK_FOUND=no
29335 29335 else
29336 29336 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
29337 29337 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
29338 29338
29339 29339 # Extra M4 quote needed to protect [] in grep expression.
29340 29340 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
29341 29341 if test "x$FOUND_CORRECT_VERSION" = x; then
29342 29342 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
29343 29343 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
29344 29344 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
29345 29345 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
29346 29346 BOOT_JDK_FOUND=no
29347 29347 else
29348 29348 # We're done! :-)
29349 29349 BOOT_JDK_FOUND=yes
29350 29350
29351 29351 # Only process if variable expands to non-empty
29352 29352
29353 29353 if test "x$BOOT_JDK" != x; then
29354 29354 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29355 29355
29356 29356 # Input might be given as Windows format, start by converting to
29357 29357 # unix format.
29358 29358 path="$BOOT_JDK"
29359 29359 new_path=`$CYGPATH -u "$path"`
29360 29360
29361 29361 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
29362 29362 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
29363 29363 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
29364 29364 # "foo.exe" is OK but "foo" is an error.
29365 29365 #
29366 29366 # This test is therefore slightly more accurate than "test -f" to check for file precense.
29367 29367 # It is also a way to make sure we got the proper file name for the real test later on.
29368 29368 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
29369 29369 if test "x$test_shortpath" = x; then
29370 29370 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29371 29371 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29372 29372 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
29373 29373 fi
29374 29374
29375 29375 # Call helper function which possibly converts this using DOS-style short mode.
29376 29376 # If so, the updated path is stored in $new_path.
29377 29377
29378 29378 input_path="$new_path"
29379 29379 # Check if we need to convert this using DOS-style short mode. If the path
29380 29380 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29381 29381 # take no chances and rewrite it.
29382 29382 # Note: m4 eats our [], so we need to use [ and ] instead.
29383 29383 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29384 29384 if test "x$has_forbidden_chars" != x; then
29385 29385 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29386 29386 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29387 29387 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29388 29388 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29389 29389 # Going to short mode and back again did indeed matter. Since short mode is
29390 29390 # case insensitive, let's make it lowercase to improve readability.
29391 29391 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29392 29392 # Now convert it back to Unix-style (cygpath)
29393 29393 input_path=`$CYGPATH -u "$shortmode_path"`
29394 29394 new_path="$input_path"
29395 29395 fi
29396 29396 fi
29397 29397
29398 29398 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29399 29399 if test "x$test_cygdrive_prefix" = x; then
29400 29400 # As a simple fix, exclude /usr/bin since it's not a real path.
29401 29401 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
29402 29402 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29403 29403 # a path prefixed by /cygdrive for fixpath to work.
29404 29404 new_path="$CYGWIN_ROOT_PATH$input_path"
29405 29405 fi
29406 29406 fi
29407 29407
29408 29408
29409 29409 if test "x$path" != "x$new_path"; then
29410 29410 BOOT_JDK="$new_path"
29411 29411 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29412 29412 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29413 29413 fi
29414 29414
29415 29415 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29416 29416
29417 29417 path="$BOOT_JDK"
29418 29418 has_colon=`$ECHO $path | $GREP ^.:`
29419 29419 new_path="$path"
29420 29420 if test "x$has_colon" = x; then
29421 29421 # Not in mixed or Windows style, start by that.
29422 29422 new_path=`cmd //c echo $path`
29423 29423 fi
29424 29424
29425 29425
29426 29426 input_path="$new_path"
29427 29427 # Check if we need to convert this using DOS-style short mode. If the path
29428 29428 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29429 29429 # take no chances and rewrite it.
29430 29430 # Note: m4 eats our [], so we need to use [ and ] instead.
29431 29431 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
29432 29432 if test "x$has_forbidden_chars" != x; then
29433 29433 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29434 29434 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29435 29435 fi
29436 29436
29437 29437
29438 29438 windows_path="$new_path"
29439 29439 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29440 29440 unix_path=`$CYGPATH -u "$windows_path"`
29441 29441 new_path="$unix_path"
29442 29442 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29443 29443 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29444 29444 new_path="$unix_path"
29445 29445 fi
29446 29446
29447 29447 if test "x$path" != "x$new_path"; then
29448 29448 BOOT_JDK="$new_path"
29449 29449 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29450 29450 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29451 29451 fi
29452 29452
29453 29453 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29454 29454 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29455 29455
29456 29456 else
29457 29457 # We're on a unix platform. Hooray! :)
29458 29458 path="$BOOT_JDK"
29459 29459 has_space=`$ECHO "$path" | $GREP " "`
29460 29460 if test "x$has_space" != x; then
29461 29461 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29462 29462 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29463 29463 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
29464 29464 fi
29465 29465
29466 29466 # Use eval to expand a potential ~
29467 29467 eval path="$path"
29468 29468 if test ! -f "$path" && test ! -d "$path"; then
29469 29469 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
29470 29470 fi
29471 29471
29472 29472 if test -d "$path"; then
29473 29473 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
29474 29474 else
29475 29475 dir="`$DIRNAME "$path"`"
29476 29476 base="`$BASENAME "$path"`"
29477 29477 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
29478 29478 fi
29479 29479 fi
29480 29480 fi
29481 29481
29482 29482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
29483 29483 $as_echo_n "checking for Boot JDK... " >&6; }
29484 29484 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
29485 29485 $as_echo "$BOOT_JDK" >&6; }
29486 29486 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
29487 29487 $as_echo_n "checking Boot JDK version... " >&6; }
29488 29488 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
29489 29489 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
29490 29490 $as_echo "$BOOT_JDK_VERSION" >&6; }
29491 29491 fi # end check jdk version
29492 29492 fi # end check javac
29493 29493 fi # end check java
29494 29494 fi # end check boot jdk found
29495 29495 fi
29496 29496
29497 29497 done
29498 29498 fi
29499 29499
29500 29500
29501 29501 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
29502 29502 if test "x$BOOT_JDK_FOUND" = xmaybe; then
29503 29503 # Do we have a bin/java?
29504 29504 if test ! -x "$BOOT_JDK/bin/java"; then
29505 29505 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
29506 29506 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
29507 29507 BOOT_JDK_FOUND=no
29508 29508 else
29509 29509 # Do we have a bin/javac?
29510 29510 if test ! -x "$BOOT_JDK/bin/javac"; then
29511 29511 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
29512 29512 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
29513 29513 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
29514 29514 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
29515 29515 BOOT_JDK_FOUND=no
29516 29516 else
29517 29517 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
29518 29518 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
29519 29519
29520 29520 # Extra M4 quote needed to protect [] in grep expression.
29521 29521 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
29522 29522 if test "x$FOUND_CORRECT_VERSION" = x; then
29523 29523 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
29524 29524 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
29525 29525 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
29526 29526 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
29527 29527 BOOT_JDK_FOUND=no
29528 29528 else
29529 29529 # We're done! :-)
29530 29530 BOOT_JDK_FOUND=yes
29531 29531
29532 29532 # Only process if variable expands to non-empty
29533 29533
29534 29534 if test "x$BOOT_JDK" != x; then
29535 29535 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29536 29536
29537 29537 # Input might be given as Windows format, start by converting to
29538 29538 # unix format.
29539 29539 path="$BOOT_JDK"
29540 29540 new_path=`$CYGPATH -u "$path"`
29541 29541
29542 29542 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
29543 29543 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
29544 29544 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
29545 29545 # "foo.exe" is OK but "foo" is an error.
29546 29546 #
29547 29547 # This test is therefore slightly more accurate than "test -f" to check for file precense.
29548 29548 # It is also a way to make sure we got the proper file name for the real test later on.
29549 29549 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
29550 29550 if test "x$test_shortpath" = x; then
29551 29551 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29552 29552 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29553 29553 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
29554 29554 fi
29555 29555
29556 29556 # Call helper function which possibly converts this using DOS-style short mode.
29557 29557 # If so, the updated path is stored in $new_path.
29558 29558
29559 29559 input_path="$new_path"
29560 29560 # Check if we need to convert this using DOS-style short mode. If the path
29561 29561 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29562 29562 # take no chances and rewrite it.
29563 29563 # Note: m4 eats our [], so we need to use [ and ] instead.
29564 29564 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29565 29565 if test "x$has_forbidden_chars" != x; then
29566 29566 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29567 29567 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29568 29568 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29569 29569 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29570 29570 # Going to short mode and back again did indeed matter. Since short mode is
29571 29571 # case insensitive, let's make it lowercase to improve readability.
29572 29572 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29573 29573 # Now convert it back to Unix-style (cygpath)
29574 29574 input_path=`$CYGPATH -u "$shortmode_path"`
29575 29575 new_path="$input_path"
29576 29576 fi
29577 29577 fi
29578 29578
29579 29579 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29580 29580 if test "x$test_cygdrive_prefix" = x; then
29581 29581 # As a simple fix, exclude /usr/bin since it's not a real path.
29582 29582 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
29583 29583 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29584 29584 # a path prefixed by /cygdrive for fixpath to work.
29585 29585 new_path="$CYGWIN_ROOT_PATH$input_path"
29586 29586 fi
29587 29587 fi
29588 29588
29589 29589
29590 29590 if test "x$path" != "x$new_path"; then
29591 29591 BOOT_JDK="$new_path"
29592 29592 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29593 29593 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29594 29594 fi
29595 29595
29596 29596 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29597 29597
29598 29598 path="$BOOT_JDK"
29599 29599 has_colon=`$ECHO $path | $GREP ^.:`
29600 29600 new_path="$path"
29601 29601 if test "x$has_colon" = x; then
29602 29602 # Not in mixed or Windows style, start by that.
29603 29603 new_path=`cmd //c echo $path`
29604 29604 fi
29605 29605
29606 29606
29607 29607 input_path="$new_path"
29608 29608 # Check if we need to convert this using DOS-style short mode. If the path
29609 29609 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29610 29610 # take no chances and rewrite it.
29611 29611 # Note: m4 eats our [], so we need to use [ and ] instead.
29612 29612 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
29613 29613 if test "x$has_forbidden_chars" != x; then
29614 29614 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29615 29615 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29616 29616 fi
29617 29617
29618 29618
29619 29619 windows_path="$new_path"
29620 29620 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29621 29621 unix_path=`$CYGPATH -u "$windows_path"`
29622 29622 new_path="$unix_path"
29623 29623 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29624 29624 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29625 29625 new_path="$unix_path"
29626 29626 fi
29627 29627
29628 29628 if test "x$path" != "x$new_path"; then
29629 29629 BOOT_JDK="$new_path"
29630 29630 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29631 29631 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29632 29632 fi
29633 29633
29634 29634 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29635 29635 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29636 29636
29637 29637 else
29638 29638 # We're on a unix platform. Hooray! :)
29639 29639 path="$BOOT_JDK"
29640 29640 has_space=`$ECHO "$path" | $GREP " "`
29641 29641 if test "x$has_space" != x; then
29642 29642 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29643 29643 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29644 29644 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
29645 29645 fi
29646 29646
29647 29647 # Use eval to expand a potential ~
29648 29648 eval path="$path"
29649 29649 if test ! -f "$path" && test ! -d "$path"; then
29650 29650 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
29651 29651 fi
29652 29652
29653 29653 if test -d "$path"; then
29654 29654 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
29655 29655 else
29656 29656 dir="`$DIRNAME "$path"`"
29657 29657 base="`$BASENAME "$path"`"
29658 29658 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
29659 29659 fi
29660 29660 fi
29661 29661 fi
29662 29662
29663 29663 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
29664 29664 $as_echo_n "checking for Boot JDK... " >&6; }
29665 29665 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
29666 29666 $as_echo "$BOOT_JDK" >&6; }
29667 29667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
29668 29668 $as_echo_n "checking Boot JDK version... " >&6; }
29669 29669 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
29670 29670 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
29671 29671 $as_echo "$BOOT_JDK_VERSION" >&6; }
29672 29672 fi # end check jdk version
29673 29673 fi # end check javac
29674 29674 fi # end check java
29675 29675 fi # end check boot jdk found
29676 29676 fi
29677 29677
29678 29678 fi
29679 29679
29680 29680
29681 29681 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
29682 29682 if test "x$BOOT_JDK_FOUND" = xmaybe; then
29683 29683 # Do we have a bin/java?
29684 29684 if test ! -x "$BOOT_JDK/bin/java"; then
29685 29685 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
29686 29686 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
29687 29687 BOOT_JDK_FOUND=no
29688 29688 else
29689 29689 # Do we have a bin/javac?
29690 29690 if test ! -x "$BOOT_JDK/bin/javac"; then
29691 29691 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
29692 29692 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
29693 29693 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
29694 29694 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
29695 29695 BOOT_JDK_FOUND=no
29696 29696 else
29697 29697 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
29698 29698 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
29699 29699
29700 29700 # Extra M4 quote needed to protect [] in grep expression.
29701 29701 FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
29702 29702 if test "x$FOUND_CORRECT_VERSION" = x; then
29703 29703 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
29704 29704 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
29705 29705 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
29706 29706 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
29707 29707 BOOT_JDK_FOUND=no
29708 29708 else
29709 29709 # We're done! :-)
29710 29710 BOOT_JDK_FOUND=yes
29711 29711
29712 29712 # Only process if variable expands to non-empty
29713 29713
29714 29714 if test "x$BOOT_JDK" != x; then
29715 29715 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29716 29716
29717 29717 # Input might be given as Windows format, start by converting to
29718 29718 # unix format.
29719 29719 path="$BOOT_JDK"
29720 29720 new_path=`$CYGPATH -u "$path"`
29721 29721
29722 29722 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
29723 29723 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
29724 29724 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
29725 29725 # "foo.exe" is OK but "foo" is an error.
29726 29726 #
29727 29727 # This test is therefore slightly more accurate than "test -f" to check for file precense.
29728 29728 # It is also a way to make sure we got the proper file name for the real test later on.
29729 29729 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
29730 29730 if test "x$test_shortpath" = x; then
29731 29731 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29732 29732 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29733 29733 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
29734 29734 fi
29735 29735
29736 29736 # Call helper function which possibly converts this using DOS-style short mode.
29737 29737 # If so, the updated path is stored in $new_path.
29738 29738
29739 29739 input_path="$new_path"
29740 29740 # Check if we need to convert this using DOS-style short mode. If the path
29741 29741 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29742 29742 # take no chances and rewrite it.
29743 29743 # Note: m4 eats our [], so we need to use [ and ] instead.
29744 29744 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29745 29745 if test "x$has_forbidden_chars" != x; then
29746 29746 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29747 29747 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29748 29748 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29749 29749 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29750 29750 # Going to short mode and back again did indeed matter. Since short mode is
29751 29751 # case insensitive, let's make it lowercase to improve readability.
29752 29752 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29753 29753 # Now convert it back to Unix-style (cygpath)
29754 29754 input_path=`$CYGPATH -u "$shortmode_path"`
29755 29755 new_path="$input_path"
29756 29756 fi
29757 29757 fi
29758 29758
29759 29759 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29760 29760 if test "x$test_cygdrive_prefix" = x; then
29761 29761 # As a simple fix, exclude /usr/bin since it's not a real path.
29762 29762 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
29763 29763 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29764 29764 # a path prefixed by /cygdrive for fixpath to work.
29765 29765 new_path="$CYGWIN_ROOT_PATH$input_path"
29766 29766 fi
29767 29767 fi
29768 29768
29769 29769
29770 29770 if test "x$path" != "x$new_path"; then
29771 29771 BOOT_JDK="$new_path"
29772 29772 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29773 29773 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29774 29774 fi
29775 29775
29776 29776 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29777 29777
29778 29778 path="$BOOT_JDK"
29779 29779 has_colon=`$ECHO $path | $GREP ^.:`
29780 29780 new_path="$path"
29781 29781 if test "x$has_colon" = x; then
29782 29782 # Not in mixed or Windows style, start by that.
29783 29783 new_path=`cmd //c echo $path`
29784 29784 fi
29785 29785
29786 29786
29787 29787 input_path="$new_path"
29788 29788 # Check if we need to convert this using DOS-style short mode. If the path
29789 29789 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29790 29790 # take no chances and rewrite it.
29791 29791 # Note: m4 eats our [], so we need to use [ and ] instead.
29792 29792 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
29793 29793 if test "x$has_forbidden_chars" != x; then
29794 29794 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29795 29795 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29796 29796 fi
29797 29797
29798 29798
29799 29799 windows_path="$new_path"
29800 29800 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29801 29801 unix_path=`$CYGPATH -u "$windows_path"`
29802 29802 new_path="$unix_path"
29803 29803 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29804 29804 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29805 29805 new_path="$unix_path"
29806 29806 fi
29807 29807
29808 29808 if test "x$path" != "x$new_path"; then
29809 29809 BOOT_JDK="$new_path"
29810 29810 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
29811 29811 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
29812 29812 fi
29813 29813
29814 29814 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29815 29815 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29816 29816
29817 29817 else
29818 29818 # We're on a unix platform. Hooray! :)
29819 29819 path="$BOOT_JDK"
29820 29820 has_space=`$ECHO "$path" | $GREP " "`
29821 29821 if test "x$has_space" != x; then
29822 29822 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
29823 29823 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
29824 29824 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
29825 29825 fi
29826 29826
29827 29827 # Use eval to expand a potential ~
29828 29828 eval path="$path"
29829 29829 if test ! -f "$path" && test ! -d "$path"; then
29830 29830 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
29831 29831 fi
29832 29832
29833 29833 if test -d "$path"; then
29834 29834 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
29835 29835 else
29836 29836 dir="`$DIRNAME "$path"`"
29837 29837 base="`$BASENAME "$path"`"
29838 29838 BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
29839 29839 fi
29840 29840 fi
29841 29841 fi
29842 29842
29843 29843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
29844 29844 $as_echo_n "checking for Boot JDK... " >&6; }
29845 29845 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
29846 29846 $as_echo "$BOOT_JDK" >&6; }
29847 29847 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
29848 29848 $as_echo_n "checking Boot JDK version... " >&6; }
29849 29849 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
29850 29850 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
29851 29851 $as_echo "$BOOT_JDK_VERSION" >&6; }
29852 29852 fi # end check jdk version
29853 29853 fi # end check javac
29854 29854 fi # end check java
29855 29855 fi # end check boot jdk found
29856 29856 fi
29857 29857
29858 29858
29859 29859 # If we haven't found anything yet, we've truly lost. Give up.
29860 29860 if test "x$BOOT_JDK_FOUND" = xno; then
29861 29861
29862 29862 # Print a helpful message on how to acquire the necessary build dependency.
29863 29863 # openjdk is the help tag: freetype, cups, alsa etc
29864 29864 MISSING_DEPENDENCY=openjdk
29865 29865
29866 29866 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29867 29867 cygwin_help $MISSING_DEPENDENCY
29868 29868 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29869 29869 msys_help $MISSING_DEPENDENCY
29870 29870 else
29871 29871 PKGHANDLER_COMMAND=
29872 29872
29873 29873 case $PKGHANDLER in
29874 29874 apt-get)
29875 29875 apt_help $MISSING_DEPENDENCY ;;
29876 29876 yum)
29877 29877 yum_help $MISSING_DEPENDENCY ;;
29878 29878 port)
29879 29879 port_help $MISSING_DEPENDENCY ;;
29880 29880 pkgutil)
29881 29881 pkgutil_help $MISSING_DEPENDENCY ;;
29882 29882 pkgadd)
29883 29883 pkgadd_help $MISSING_DEPENDENCY ;;
29884 29884 esac
29885 29885
29886 29886 if test "x$PKGHANDLER_COMMAND" != x; then
29887 29887 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
29888 29888 fi
29889 29889 fi
29890 29890
29891 29891 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
29892 29892 $as_echo "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
29893 29893 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
29894 29894 $as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
29895 29895 as_fn_error $? "Cannot continue" "$LINENO" 5
29896 29896 fi
29897 29897
29898 29898
29899 29899
29900 29900 # Setup tools from the Boot JDK.
29901 29901
29902 29902 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
29903 29903
29904 29904 # Publish this variable in the help.
29905 29905
29906 29906
29907 29907 if [ -z "${JAVA+x}" ]; then
29908 29908 # The variable is not set by user, try to locate tool using the code snippet
29909 29909
29910 29910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
29911 29911 $as_echo_n "checking for java in Boot JDK... " >&6; }
29912 29912 JAVA=$BOOT_JDK/bin/java
29913 29913 if test ! -x $JAVA; then
29914 29914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
29915 29915 $as_echo "not found" >&6; }
29916 29916 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
29917 29917 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
29918 29918 as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
29919 29919 fi
29920 29920 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
29921 29921 $as_echo "ok" >&6; }
29922 29922
29923 29923
29924 29924 else
29925 29925 # The variable is set, but is it from the command line or the environment?
29926 29926
29927 29927 # Try to remove the string !JAVA! from our list.
29928 29928 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVA!/}
29929 29929 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
29930 29930 # If it failed, the variable was not from the command line. Ignore it,
29931 29931 # but warn the user (except for BASH, which is always set by the calling BASH).
29932 29932 if test "xJAVA" != xBASH; then
29933 29933 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVA from the environment. Use command line variables instead." >&5
29934 29934 $as_echo "$as_me: WARNING: Ignoring value of JAVA from the environment. Use command line variables instead." >&2;}
29935 29935 fi
29936 29936 # Try to locate tool using the code snippet
29937 29937
29938 29938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
29939 29939 $as_echo_n "checking for java in Boot JDK... " >&6; }
29940 29940 JAVA=$BOOT_JDK/bin/java
29941 29941 if test ! -x $JAVA; then
29942 29942 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
29943 29943 $as_echo "not found" >&6; }
29944 29944 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
29945 29945 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
29946 29946 as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
29947 29947 fi
29948 29948 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
29949 29949 $as_echo "ok" >&6; }
29950 29950
29951 29951
29952 29952 else
29953 29953 # If it succeeded, then it was overridden by the user. We will use it
29954 29954 # for the tool.
29955 29955
29956 29956 # First remove it from the list of overridden variables, so we can test
29957 29957 # for unknown variables in the end.
29958 29958 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
29959 29959
29960 29960 # Check if we try to supply an empty value
29961 29961 if test "x$JAVA" = x; then
29962 29962 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVA= (no value)" >&5
29963 29963 $as_echo "$as_me: Setting user supplied tool JAVA= (no value)" >&6;}
29964 29964 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVA" >&5
29965 29965 $as_echo_n "checking for JAVA... " >&6; }
29966 29966 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
29967 29967 $as_echo "disabled" >&6; }
29968 29968 else
29969 29969 # Check if the provided tool contains a complete path.
29970 29970 tool_specified="$JAVA"
29971 29971 tool_basename="${tool_specified##*/}"
29972 29972 if test "x$tool_basename" = "x$tool_specified"; then
29973 29973 # A command without a complete path is provided, search $PATH.
29974 29974 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVA=$tool_basename" >&5
29975 29975 $as_echo "$as_me: Will search for user supplied tool JAVA=$tool_basename" >&6;}
29976 29976 # Extract the first word of "$tool_basename", so it can be a program name with args.
29977 29977 set dummy $tool_basename; ac_word=$2
29978 29978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
29979 29979 $as_echo_n "checking for $ac_word... " >&6; }
29980 29980 if ${ac_cv_path_JAVA+:} false; then :
29981 29981 $as_echo_n "(cached) " >&6
29982 29982 else
29983 29983 case $JAVA in
29984 29984 [\\/]* | ?:[\\/]*)
29985 29985 ac_cv_path_JAVA="$JAVA" # Let the user override the test with a path.
29986 29986 ;;
29987 29987 *)
29988 29988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
29989 29989 for as_dir in $PATH
29990 29990 do
29991 29991 IFS=$as_save_IFS
29992 29992 test -z "$as_dir" && as_dir=.
29993 29993 for ac_exec_ext in '' $ac_executable_extensions; do
29994 29994 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
29995 29995 ac_cv_path_JAVA="$as_dir/$ac_word$ac_exec_ext"
29996 29996 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
29997 29997 break 2
29998 29998 fi
29999 29999 done
30000 30000 done
30001 30001 IFS=$as_save_IFS
30002 30002
30003 30003 ;;
30004 30004 esac
30005 30005 fi
30006 30006 JAVA=$ac_cv_path_JAVA
30007 30007 if test -n "$JAVA"; then
30008 30008 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5
30009 30009 $as_echo "$JAVA" >&6; }
30010 30010 else
30011 30011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30012 30012 $as_echo "no" >&6; }
30013 30013 fi
30014 30014
30015 30015
30016 30016 if test "x$JAVA" = x; then
30017 30017 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
30018 30018 fi
30019 30019 else
30020 30020 # Otherwise we believe it is a complete path. Use it as it is.
30021 30021 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVA=$tool_specified" >&5
30022 30022 $as_echo "$as_me: Will use user supplied tool JAVA=$tool_specified" >&6;}
30023 30023 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVA" >&5
30024 30024 $as_echo_n "checking for JAVA... " >&6; }
30025 30025 if test ! -x "$tool_specified"; then
30026 30026 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30027 30027 $as_echo "not found" >&6; }
30028 30028 as_fn_error $? "User supplied tool JAVA=$tool_specified does not exist or is not executable" "$LINENO" 5
30029 30029 fi
30030 30030 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
30031 30031 $as_echo "$tool_specified" >&6; }
30032 30032 fi
30033 30033 fi
30034 30034 fi
30035 30035
30036 30036 fi
30037 30037
30038 30038
30039 30039
30040 30040 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
30041 30041
30042 30042 # Publish this variable in the help.
30043 30043
30044 30044
30045 30045 if [ -z "${JAVAC+x}" ]; then
30046 30046 # The variable is not set by user, try to locate tool using the code snippet
30047 30047
30048 30048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
30049 30049 $as_echo_n "checking for javac in Boot JDK... " >&6; }
30050 30050 JAVAC=$BOOT_JDK/bin/javac
30051 30051 if test ! -x $JAVAC; then
30052 30052 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30053 30053 $as_echo "not found" >&6; }
30054 30054 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30055 30055 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30056 30056 as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
30057 30057 fi
30058 30058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30059 30059 $as_echo "ok" >&6; }
30060 30060
30061 30061
30062 30062 else
30063 30063 # The variable is set, but is it from the command line or the environment?
30064 30064
30065 30065 # Try to remove the string !JAVAC! from our list.
30066 30066 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVAC!/}
30067 30067 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
30068 30068 # If it failed, the variable was not from the command line. Ignore it,
30069 30069 # but warn the user (except for BASH, which is always set by the calling BASH).
30070 30070 if test "xJAVAC" != xBASH; then
30071 30071 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVAC from the environment. Use command line variables instead." >&5
30072 30072 $as_echo "$as_me: WARNING: Ignoring value of JAVAC from the environment. Use command line variables instead." >&2;}
30073 30073 fi
30074 30074 # Try to locate tool using the code snippet
30075 30075
30076 30076 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
30077 30077 $as_echo_n "checking for javac in Boot JDK... " >&6; }
30078 30078 JAVAC=$BOOT_JDK/bin/javac
30079 30079 if test ! -x $JAVAC; then
30080 30080 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30081 30081 $as_echo "not found" >&6; }
30082 30082 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30083 30083 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30084 30084 as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
30085 30085 fi
30086 30086 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30087 30087 $as_echo "ok" >&6; }
30088 30088
30089 30089
30090 30090 else
30091 30091 # If it succeeded, then it was overridden by the user. We will use it
30092 30092 # for the tool.
30093 30093
30094 30094 # First remove it from the list of overridden variables, so we can test
30095 30095 # for unknown variables in the end.
30096 30096 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
30097 30097
30098 30098 # Check if we try to supply an empty value
30099 30099 if test "x$JAVAC" = x; then
30100 30100 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVAC= (no value)" >&5
30101 30101 $as_echo "$as_me: Setting user supplied tool JAVAC= (no value)" >&6;}
30102 30102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAC" >&5
30103 30103 $as_echo_n "checking for JAVAC... " >&6; }
30104 30104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
30105 30105 $as_echo "disabled" >&6; }
30106 30106 else
30107 30107 # Check if the provided tool contains a complete path.
30108 30108 tool_specified="$JAVAC"
30109 30109 tool_basename="${tool_specified##*/}"
30110 30110 if test "x$tool_basename" = "x$tool_specified"; then
30111 30111 # A command without a complete path is provided, search $PATH.
30112 30112 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVAC=$tool_basename" >&5
30113 30113 $as_echo "$as_me: Will search for user supplied tool JAVAC=$tool_basename" >&6;}
30114 30114 # Extract the first word of "$tool_basename", so it can be a program name with args.
30115 30115 set dummy $tool_basename; ac_word=$2
30116 30116 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
30117 30117 $as_echo_n "checking for $ac_word... " >&6; }
30118 30118 if ${ac_cv_path_JAVAC+:} false; then :
30119 30119 $as_echo_n "(cached) " >&6
30120 30120 else
30121 30121 case $JAVAC in
30122 30122 [\\/]* | ?:[\\/]*)
30123 30123 ac_cv_path_JAVAC="$JAVAC" # Let the user override the test with a path.
30124 30124 ;;
30125 30125 *)
30126 30126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
30127 30127 for as_dir in $PATH
30128 30128 do
30129 30129 IFS=$as_save_IFS
30130 30130 test -z "$as_dir" && as_dir=.
30131 30131 for ac_exec_ext in '' $ac_executable_extensions; do
30132 30132 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
30133 30133 ac_cv_path_JAVAC="$as_dir/$ac_word$ac_exec_ext"
30134 30134 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
30135 30135 break 2
30136 30136 fi
30137 30137 done
30138 30138 done
30139 30139 IFS=$as_save_IFS
30140 30140
30141 30141 ;;
30142 30142 esac
30143 30143 fi
30144 30144 JAVAC=$ac_cv_path_JAVAC
30145 30145 if test -n "$JAVAC"; then
30146 30146 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5
30147 30147 $as_echo "$JAVAC" >&6; }
30148 30148 else
30149 30149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30150 30150 $as_echo "no" >&6; }
30151 30151 fi
30152 30152
30153 30153
30154 30154 if test "x$JAVAC" = x; then
30155 30155 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
30156 30156 fi
30157 30157 else
30158 30158 # Otherwise we believe it is a complete path. Use it as it is.
30159 30159 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVAC=$tool_specified" >&5
30160 30160 $as_echo "$as_me: Will use user supplied tool JAVAC=$tool_specified" >&6;}
30161 30161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAC" >&5
30162 30162 $as_echo_n "checking for JAVAC... " >&6; }
30163 30163 if test ! -x "$tool_specified"; then
30164 30164 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30165 30165 $as_echo "not found" >&6; }
30166 30166 as_fn_error $? "User supplied tool JAVAC=$tool_specified does not exist or is not executable" "$LINENO" 5
30167 30167 fi
30168 30168 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
30169 30169 $as_echo "$tool_specified" >&6; }
30170 30170 fi
30171 30171 fi
30172 30172 fi
30173 30173
30174 30174 fi
30175 30175
30176 30176
30177 30177
30178 30178 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
30179 30179
30180 30180 # Publish this variable in the help.
30181 30181
30182 30182
30183 30183 if [ -z "${JAVAH+x}" ]; then
30184 30184 # The variable is not set by user, try to locate tool using the code snippet
30185 30185
30186 30186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
30187 30187 $as_echo_n "checking for javah in Boot JDK... " >&6; }
30188 30188 JAVAH=$BOOT_JDK/bin/javah
30189 30189 if test ! -x $JAVAH; then
30190 30190 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30191 30191 $as_echo "not found" >&6; }
30192 30192 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30193 30193 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30194 30194 as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
30195 30195 fi
30196 30196 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30197 30197 $as_echo "ok" >&6; }
30198 30198
30199 30199
30200 30200 else
30201 30201 # The variable is set, but is it from the command line or the environment?
30202 30202
30203 30203 # Try to remove the string !JAVAH! from our list.
30204 30204 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVAH!/}
30205 30205 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
30206 30206 # If it failed, the variable was not from the command line. Ignore it,
30207 30207 # but warn the user (except for BASH, which is always set by the calling BASH).
30208 30208 if test "xJAVAH" != xBASH; then
30209 30209 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVAH from the environment. Use command line variables instead." >&5
30210 30210 $as_echo "$as_me: WARNING: Ignoring value of JAVAH from the environment. Use command line variables instead." >&2;}
30211 30211 fi
30212 30212 # Try to locate tool using the code snippet
30213 30213
30214 30214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
30215 30215 $as_echo_n "checking for javah in Boot JDK... " >&6; }
30216 30216 JAVAH=$BOOT_JDK/bin/javah
30217 30217 if test ! -x $JAVAH; then
30218 30218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30219 30219 $as_echo "not found" >&6; }
30220 30220 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30221 30221 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30222 30222 as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
30223 30223 fi
30224 30224 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30225 30225 $as_echo "ok" >&6; }
30226 30226
30227 30227
30228 30228 else
30229 30229 # If it succeeded, then it was overridden by the user. We will use it
30230 30230 # for the tool.
30231 30231
30232 30232 # First remove it from the list of overridden variables, so we can test
30233 30233 # for unknown variables in the end.
30234 30234 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
30235 30235
30236 30236 # Check if we try to supply an empty value
30237 30237 if test "x$JAVAH" = x; then
30238 30238 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVAH= (no value)" >&5
30239 30239 $as_echo "$as_me: Setting user supplied tool JAVAH= (no value)" >&6;}
30240 30240 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAH" >&5
30241 30241 $as_echo_n "checking for JAVAH... " >&6; }
30242 30242 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
30243 30243 $as_echo "disabled" >&6; }
30244 30244 else
30245 30245 # Check if the provided tool contains a complete path.
30246 30246 tool_specified="$JAVAH"
30247 30247 tool_basename="${tool_specified##*/}"
30248 30248 if test "x$tool_basename" = "x$tool_specified"; then
30249 30249 # A command without a complete path is provided, search $PATH.
30250 30250 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVAH=$tool_basename" >&5
30251 30251 $as_echo "$as_me: Will search for user supplied tool JAVAH=$tool_basename" >&6;}
30252 30252 # Extract the first word of "$tool_basename", so it can be a program name with args.
30253 30253 set dummy $tool_basename; ac_word=$2
30254 30254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
30255 30255 $as_echo_n "checking for $ac_word... " >&6; }
30256 30256 if ${ac_cv_path_JAVAH+:} false; then :
30257 30257 $as_echo_n "(cached) " >&6
30258 30258 else
30259 30259 case $JAVAH in
30260 30260 [\\/]* | ?:[\\/]*)
30261 30261 ac_cv_path_JAVAH="$JAVAH" # Let the user override the test with a path.
30262 30262 ;;
30263 30263 *)
30264 30264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
30265 30265 for as_dir in $PATH
30266 30266 do
30267 30267 IFS=$as_save_IFS
30268 30268 test -z "$as_dir" && as_dir=.
30269 30269 for ac_exec_ext in '' $ac_executable_extensions; do
30270 30270 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
30271 30271 ac_cv_path_JAVAH="$as_dir/$ac_word$ac_exec_ext"
30272 30272 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
30273 30273 break 2
30274 30274 fi
30275 30275 done
30276 30276 done
30277 30277 IFS=$as_save_IFS
30278 30278
30279 30279 ;;
30280 30280 esac
30281 30281 fi
30282 30282 JAVAH=$ac_cv_path_JAVAH
30283 30283 if test -n "$JAVAH"; then
30284 30284 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAH" >&5
30285 30285 $as_echo "$JAVAH" >&6; }
30286 30286 else
30287 30287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30288 30288 $as_echo "no" >&6; }
30289 30289 fi
30290 30290
30291 30291
30292 30292 if test "x$JAVAH" = x; then
30293 30293 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
30294 30294 fi
30295 30295 else
30296 30296 # Otherwise we believe it is a complete path. Use it as it is.
30297 30297 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVAH=$tool_specified" >&5
30298 30298 $as_echo "$as_me: Will use user supplied tool JAVAH=$tool_specified" >&6;}
30299 30299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAH" >&5
30300 30300 $as_echo_n "checking for JAVAH... " >&6; }
30301 30301 if test ! -x "$tool_specified"; then
30302 30302 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30303 30303 $as_echo "not found" >&6; }
30304 30304 as_fn_error $? "User supplied tool JAVAH=$tool_specified does not exist or is not executable" "$LINENO" 5
30305 30305 fi
30306 30306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
30307 30307 $as_echo "$tool_specified" >&6; }
30308 30308 fi
30309 30309 fi
30310 30310 fi
30311 30311
30312 30312 fi
30313 30313
30314 30314
30315 30315
30316 30316 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
30317 30317
30318 30318 # Publish this variable in the help.
30319 30319
30320 30320
30321 30321 if [ -z "${JAR+x}" ]; then
30322 30322 # The variable is not set by user, try to locate tool using the code snippet
30323 30323
30324 30324 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
30325 30325 $as_echo_n "checking for jar in Boot JDK... " >&6; }
30326 30326 JAR=$BOOT_JDK/bin/jar
30327 30327 if test ! -x $JAR; then
30328 30328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30329 30329 $as_echo "not found" >&6; }
30330 30330 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30331 30331 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30332 30332 as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
30333 30333 fi
30334 30334 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30335 30335 $as_echo "ok" >&6; }
30336 30336
30337 30337
30338 30338 else
30339 30339 # The variable is set, but is it from the command line or the environment?
30340 30340
30341 30341 # Try to remove the string !JAR! from our list.
30342 30342 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAR!/}
30343 30343 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
30344 30344 # If it failed, the variable was not from the command line. Ignore it,
30345 30345 # but warn the user (except for BASH, which is always set by the calling BASH).
30346 30346 if test "xJAR" != xBASH; then
30347 30347 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAR from the environment. Use command line variables instead." >&5
30348 30348 $as_echo "$as_me: WARNING: Ignoring value of JAR from the environment. Use command line variables instead." >&2;}
30349 30349 fi
30350 30350 # Try to locate tool using the code snippet
30351 30351
30352 30352 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
30353 30353 $as_echo_n "checking for jar in Boot JDK... " >&6; }
30354 30354 JAR=$BOOT_JDK/bin/jar
30355 30355 if test ! -x $JAR; then
30356 30356 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30357 30357 $as_echo "not found" >&6; }
30358 30358 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30359 30359 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30360 30360 as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
30361 30361 fi
30362 30362 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30363 30363 $as_echo "ok" >&6; }
30364 30364
30365 30365
30366 30366 else
30367 30367 # If it succeeded, then it was overridden by the user. We will use it
30368 30368 # for the tool.
30369 30369
30370 30370 # First remove it from the list of overridden variables, so we can test
30371 30371 # for unknown variables in the end.
30372 30372 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
30373 30373
30374 30374 # Check if we try to supply an empty value
30375 30375 if test "x$JAR" = x; then
30376 30376 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAR= (no value)" >&5
30377 30377 $as_echo "$as_me: Setting user supplied tool JAR= (no value)" >&6;}
30378 30378 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAR" >&5
30379 30379 $as_echo_n "checking for JAR... " >&6; }
30380 30380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
30381 30381 $as_echo "disabled" >&6; }
30382 30382 else
30383 30383 # Check if the provided tool contains a complete path.
30384 30384 tool_specified="$JAR"
30385 30385 tool_basename="${tool_specified##*/}"
30386 30386 if test "x$tool_basename" = "x$tool_specified"; then
30387 30387 # A command without a complete path is provided, search $PATH.
30388 30388 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAR=$tool_basename" >&5
30389 30389 $as_echo "$as_me: Will search for user supplied tool JAR=$tool_basename" >&6;}
30390 30390 # Extract the first word of "$tool_basename", so it can be a program name with args.
30391 30391 set dummy $tool_basename; ac_word=$2
30392 30392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
30393 30393 $as_echo_n "checking for $ac_word... " >&6; }
30394 30394 if ${ac_cv_path_JAR+:} false; then :
30395 30395 $as_echo_n "(cached) " >&6
30396 30396 else
30397 30397 case $JAR in
30398 30398 [\\/]* | ?:[\\/]*)
30399 30399 ac_cv_path_JAR="$JAR" # Let the user override the test with a path.
30400 30400 ;;
30401 30401 *)
30402 30402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
30403 30403 for as_dir in $PATH
30404 30404 do
30405 30405 IFS=$as_save_IFS
30406 30406 test -z "$as_dir" && as_dir=.
30407 30407 for ac_exec_ext in '' $ac_executable_extensions; do
30408 30408 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
30409 30409 ac_cv_path_JAR="$as_dir/$ac_word$ac_exec_ext"
30410 30410 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
30411 30411 break 2
30412 30412 fi
30413 30413 done
30414 30414 done
30415 30415 IFS=$as_save_IFS
30416 30416
30417 30417 ;;
30418 30418 esac
30419 30419 fi
30420 30420 JAR=$ac_cv_path_JAR
30421 30421 if test -n "$JAR"; then
30422 30422 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5
30423 30423 $as_echo "$JAR" >&6; }
30424 30424 else
30425 30425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30426 30426 $as_echo "no" >&6; }
30427 30427 fi
30428 30428
30429 30429
30430 30430 if test "x$JAR" = x; then
30431 30431 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
30432 30432 fi
30433 30433 else
30434 30434 # Otherwise we believe it is a complete path. Use it as it is.
30435 30435 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAR=$tool_specified" >&5
30436 30436 $as_echo "$as_me: Will use user supplied tool JAR=$tool_specified" >&6;}
30437 30437 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAR" >&5
30438 30438 $as_echo_n "checking for JAR... " >&6; }
30439 30439 if test ! -x "$tool_specified"; then
30440 30440 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30441 30441 $as_echo "not found" >&6; }
30442 30442 as_fn_error $? "User supplied tool JAR=$tool_specified does not exist or is not executable" "$LINENO" 5
30443 30443 fi
30444 30444 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
30445 30445 $as_echo "$tool_specified" >&6; }
30446 30446 fi
30447 30447 fi
30448 30448 fi
30449 30449
30450 30450 fi
30451 30451
30452 30452
30453 30453
30454 30454 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
30455 30455
30456 30456 # Publish this variable in the help.
30457 30457
30458 30458
30459 30459 if [ -z "${JARSIGNER+x}" ]; then
30460 30460 # The variable is not set by user, try to locate tool using the code snippet
30461 30461
30462 30462 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jarsigner in Boot JDK" >&5
30463 30463 $as_echo_n "checking for jarsigner in Boot JDK... " >&6; }
30464 30464 JARSIGNER=$BOOT_JDK/bin/jarsigner
30465 30465 if test ! -x $JARSIGNER; then
30466 30466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30467 30467 $as_echo "not found" >&6; }
30468 30468 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30469 30469 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30470 30470 as_fn_error $? "Could not find jarsigner in the Boot JDK" "$LINENO" 5
30471 30471 fi
30472 30472 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30473 30473 $as_echo "ok" >&6; }
30474 30474
30475 30475
30476 30476 else
30477 30477 # The variable is set, but is it from the command line or the environment?
30478 30478
30479 30479 # Try to remove the string !JARSIGNER! from our list.
30480 30480 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JARSIGNER!/}
30481 30481 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
30482 30482 # If it failed, the variable was not from the command line. Ignore it,
30483 30483 # but warn the user (except for BASH, which is always set by the calling BASH).
30484 30484 if test "xJARSIGNER" != xBASH; then
30485 30485 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JARSIGNER from the environment. Use command line variables instead." >&5
30486 30486 $as_echo "$as_me: WARNING: Ignoring value of JARSIGNER from the environment. Use command line variables instead." >&2;}
30487 30487 fi
30488 30488 # Try to locate tool using the code snippet
30489 30489
30490 30490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jarsigner in Boot JDK" >&5
30491 30491 $as_echo_n "checking for jarsigner in Boot JDK... " >&6; }
30492 30492 JARSIGNER=$BOOT_JDK/bin/jarsigner
30493 30493 if test ! -x $JARSIGNER; then
30494 30494 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30495 30495 $as_echo "not found" >&6; }
30496 30496 { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
30497 30497 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
30498 30498 as_fn_error $? "Could not find jarsigner in the Boot JDK" "$LINENO" 5
30499 30499 fi
30500 30500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
30501 30501 $as_echo "ok" >&6; }
30502 30502
30503 30503
30504 30504 else
30505 30505 # If it succeeded, then it was overridden by the user. We will use it
30506 30506 # for the tool.
30507 30507
30508 30508 # First remove it from the list of overridden variables, so we can test
30509 30509 # for unknown variables in the end.
30510 30510 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
30511 30511
30512 30512 # Check if we try to supply an empty value
30513 30513 if test "x$JARSIGNER" = x; then
30514 30514 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JARSIGNER= (no value)" >&5
30515 30515 $as_echo "$as_me: Setting user supplied tool JARSIGNER= (no value)" >&6;}
30516 30516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JARSIGNER" >&5
30517 30517 $as_echo_n "checking for JARSIGNER... " >&6; }
30518 30518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
30519 30519 $as_echo "disabled" >&6; }
30520 30520 else
30521 30521 # Check if the provided tool contains a complete path.
30522 30522 tool_specified="$JARSIGNER"
30523 30523 tool_basename="${tool_specified##*/}"
30524 30524 if test "x$tool_basename" = "x$tool_specified"; then
30525 30525 # A command without a complete path is provided, search $PATH.
30526 30526 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JARSIGNER=$tool_basename" >&5
30527 30527 $as_echo "$as_me: Will search for user supplied tool JARSIGNER=$tool_basename" >&6;}
30528 30528 # Extract the first word of "$tool_basename", so it can be a program name with args.
30529 30529 set dummy $tool_basename; ac_word=$2
30530 30530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
30531 30531 $as_echo_n "checking for $ac_word... " >&6; }
30532 30532 if ${ac_cv_path_JARSIGNER+:} false; then :
30533 30533 $as_echo_n "(cached) " >&6
30534 30534 else
30535 30535 case $JARSIGNER in
30536 30536 [\\/]* | ?:[\\/]*)
30537 30537 ac_cv_path_JARSIGNER="$JARSIGNER" # Let the user override the test with a path.
30538 30538 ;;
30539 30539 *)
30540 30540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
30541 30541 for as_dir in $PATH
30542 30542 do
30543 30543 IFS=$as_save_IFS
30544 30544 test -z "$as_dir" && as_dir=.
30545 30545 for ac_exec_ext in '' $ac_executable_extensions; do
30546 30546 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
30547 30547 ac_cv_path_JARSIGNER="$as_dir/$ac_word$ac_exec_ext"
30548 30548 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
30549 30549 break 2
30550 30550 fi
30551 30551 done
30552 30552 done
30553 30553 IFS=$as_save_IFS
30554 30554
30555 30555 ;;
30556 30556 esac
30557 30557 fi
30558 30558 JARSIGNER=$ac_cv_path_JARSIGNER
30559 30559 if test -n "$JARSIGNER"; then
30560 30560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JARSIGNER" >&5
30561 30561 $as_echo "$JARSIGNER" >&6; }
30562 30562 else
30563 30563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30564 30564 $as_echo "no" >&6; }
30565 30565 fi
30566 30566
30567 30567
30568 30568 if test "x$JARSIGNER" = x; then
30569 30569 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
30570 30570 fi
30571 30571 else
30572 30572 # Otherwise we believe it is a complete path. Use it as it is.
30573 30573 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JARSIGNER=$tool_specified" >&5
30574 30574 $as_echo "$as_me: Will use user supplied tool JARSIGNER=$tool_specified" >&6;}
30575 30575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JARSIGNER" >&5
30576 30576 $as_echo_n "checking for JARSIGNER... " >&6; }
30577 30577 if test ! -x "$tool_specified"; then
30578 30578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
30579 30579 $as_echo "not found" >&6; }
30580 30580 as_fn_error $? "User supplied tool JARSIGNER=$tool_specified does not exist or is not executable" "$LINENO" 5
30581 30581 fi
30582 30582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
30583 30583 $as_echo "$tool_specified" >&6; }
30584 30584 fi
30585 30585 fi
30586 30586 fi
30587 30587
30588 30588 fi
30589 30589
30590 30590
30591 30591
30592 30592 # Finally, set some other options...
30593 30593
30594 30594 # When compiling code to be executed by the Boot JDK, force jdk8 compatibility.
30595 30595 BOOT_JDK_SOURCETARGET="-source 8 -target 8"
30596 30596
30597 30597
30598 30598
30599 30599 $ECHO "Check if jvm arg is ok: --patch-module foo=bar" >&5
30600 30600 $ECHO "Command: $JAVA --patch-module foo=bar -version" >&5
30601 30601 OUTPUT=`$JAVA --patch-module foo=bar -version 2>&1`
30602 30602 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
30603 30603 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
30604 30604 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
30605 30605 dummy="$dummy --patch-module foo=bar"
30606 30606 JVM_ARG_OK=true
30607 30607 else
30608 30608 $ECHO "Arg failed:" >&5
30609 30609 $ECHO "$OUTPUT" >&5
30610 30610 JVM_ARG_OK=false
30611 30611 fi
30612 30612
30613 30613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK supports modules" >&5
30614 30614 $as_echo_n "checking if Boot JDK supports modules... " >&6; }
30615 30615 if test "x$JVM_ARG_OK" = "xtrue"; then
30616 30616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
30617 30617 $as_echo "yes" >&6; }
30618 30618 BOOT_JDK_MODULAR="true"
30619 30619 else
30620 30620 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30621 30621 $as_echo "no" >&6; }
30622 30622 BOOT_JDK_MODULAR="false"
30623 30623 fi
30624 30624
30625 30625
30626 30626
30627 30627
30628 30628 # Check if the boot jdk is 32 or 64 bit
30629 30629 if "$JAVA" -d64 -version > /dev/null 2>&1; then
30630 30630 BOOT_JDK_BITS="64"
30631 30631 else
30632 30632 BOOT_JDK_BITS="32"
30633 30633 fi
30634 30634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
30635 30635 $as_echo_n "checking if Boot JDK is 32 or 64 bits... " >&6; }
30636 30636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
30637 30637 $as_echo "$BOOT_JDK_BITS" >&6; }
30638 30638
30639 30639
30640 30640
30641 30641
30642 30642 # Check whether --with-build-jdk was given.
30643 30643 if test "${with_build_jdk+set}" = set; then :
30644 30644 withval=$with_build_jdk;
30645 30645 fi
30646 30646
30647 30647
30648 30648 CREATE_BUILDJDK=false
30649 30649 EXTERNAL_BUILDJDK=false
30650 30650 BUILD_JDK_FOUND="no"
30651 30651 if test "x$with_build_jdk" != "x"; then
30652 30652
30653 30653 if test "x$BUILD_JDK_FOUND" = xno; then
30654 30654 # Execute the test
30655 30655
30656 30656 if test "x$with_build_jdk" != x; then
30657 30657 BUILD_JDK=$with_build_jdk
30658 30658 BUILD_JDK_FOUND=maybe
30659 30659 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Build JDK using configure arguments" >&5
30660 30660 $as_echo "$as_me: Found potential Build JDK using configure arguments" >&6;}
30661 30661 fi
30662 30662
30663 30663 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
30664 30664 if test "x$BUILD_JDK_FOUND" = xmaybe; then
30665 30665 # Do we have a bin/java?
30666 30666 if test ! -x "$BUILD_JDK/bin/java"; then
30667 30667 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring" >&5
30668 30668 $as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring" >&6;}
30669 30669 BUILD_JDK_FOUND=no
30670 30670 elif test ! -x "$BUILD_JDK/bin/jlink"; then
30671 30671 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring" >&5
30672 30672 $as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring" >&6;}
30673 30673 BUILD_JDK_FOUND=no
30674 30674 elif test ! -x "$BUILD_JDK/bin/jmod"; then
30675 30675 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring" >&5
30676 30676 $as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring" >&6;}
30677 30677 BUILD_JDK_FOUND=no
30678 30678 elif test ! -x "$BUILD_JDK/bin/javac"; then
30679 30679 # Do we have a bin/javac?
30680 30680 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring" >&5
30681 30681 $as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring" >&6;}
30682 30682 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be a JRE instead of an JDK)" >&5
30683 30683 $as_echo "$as_me: (This might be a JRE instead of an JDK)" >&6;}
30684 30684 BUILD_JDK_FOUND=no
30685 30685 else
30686 30686 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
30687 30687 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
30688 30688
30689 30689 # Extra M4 quote needed to protect [] in grep expression.
30690 30690 FOUND_CORRECT_VERSION=`echo $BUILD_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"'`
30691 30691 if test "x$FOUND_CORRECT_VERSION" = x; then
30692 30692 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring" >&5
30693 30693 $as_echo "$as_me: Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring" >&6;}
30694 30694 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Build JDK must be version 9)" >&5
30695 30695 $as_echo "$as_me: (Your Build JDK must be version 9)" >&6;}
30696 30696 BUILD_JDK_FOUND=no
30697 30697 else
30698 30698 # We're done!
30699 30699 BUILD_JDK_FOUND=yes
30700 30700
30701 30701 # Only process if variable expands to non-empty
30702 30702
30703 30703 if test "x$BUILD_JDK" != x; then
30704 30704 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30705 30705
30706 30706 # Input might be given as Windows format, start by converting to
30707 30707 # unix format.
30708 30708 path="$BUILD_JDK"
30709 30709 new_path=`$CYGPATH -u "$path"`
30710 30710
30711 30711 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
30712 30712 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
30713 30713 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
30714 30714 # "foo.exe" is OK but "foo" is an error.
30715 30715 #
30716 30716 # This test is therefore slightly more accurate than "test -f" to check for file precense.
30717 30717 # It is also a way to make sure we got the proper file name for the real test later on.
30718 30718 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
30719 30719 if test "x$test_shortpath" = x; then
30720 30720 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&5
30721 30721 $as_echo "$as_me: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&6;}
30722 30722 as_fn_error $? "Cannot locate the the path of BUILD_JDK" "$LINENO" 5
30723 30723 fi
30724 30724
30725 30725 # Call helper function which possibly converts this using DOS-style short mode.
30726 30726 # If so, the updated path is stored in $new_path.
30727 30727
30728 30728 input_path="$new_path"
30729 30729 # Check if we need to convert this using DOS-style short mode. If the path
30730 30730 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30731 30731 # take no chances and rewrite it.
30732 30732 # Note: m4 eats our [], so we need to use [ and ] instead.
30733 30733 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
30734 30734 if test "x$has_forbidden_chars" != x; then
30735 30735 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30736 30736 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
30737 30737 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
30738 30738 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
30739 30739 # Going to short mode and back again did indeed matter. Since short mode is
30740 30740 # case insensitive, let's make it lowercase to improve readability.
30741 30741 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30742 30742 # Now convert it back to Unix-style (cygpath)
30743 30743 input_path=`$CYGPATH -u "$shortmode_path"`
30744 30744 new_path="$input_path"
30745 30745 fi
30746 30746 fi
30747 30747
30748 30748 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
30749 30749 if test "x$test_cygdrive_prefix" = x; then
30750 30750 # As a simple fix, exclude /usr/bin since it's not a real path.
30751 30751 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
30752 30752 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
30753 30753 # a path prefixed by /cygdrive for fixpath to work.
30754 30754 new_path="$CYGWIN_ROOT_PATH$input_path"
30755 30755 fi
30756 30756 fi
30757 30757
30758 30758
30759 30759 if test "x$path" != "x$new_path"; then
30760 30760 BUILD_JDK="$new_path"
30761 30761 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_JDK to \"$new_path\"" >&5
30762 30762 $as_echo "$as_me: Rewriting BUILD_JDK to \"$new_path\"" >&6;}
30763 30763 fi
30764 30764
30765 30765 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30766 30766
30767 30767 path="$BUILD_JDK"
30768 30768 has_colon=`$ECHO $path | $GREP ^.:`
30769 30769 new_path="$path"
30770 30770 if test "x$has_colon" = x; then
30771 30771 # Not in mixed or Windows style, start by that.
30772 30772 new_path=`cmd //c echo $path`
30773 30773 fi
30774 30774
30775 30775
30776 30776 input_path="$new_path"
30777 30777 # Check if we need to convert this using DOS-style short mode. If the path
30778 30778 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30779 30779 # take no chances and rewrite it.
30780 30780 # Note: m4 eats our [], so we need to use [ and ] instead.
30781 30781 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
30782 30782 if test "x$has_forbidden_chars" != x; then
30783 30783 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30784 30784 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30785 30785 fi
30786 30786
30787 30787
30788 30788 windows_path="$new_path"
30789 30789 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30790 30790 unix_path=`$CYGPATH -u "$windows_path"`
30791 30791 new_path="$unix_path"
30792 30792 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30793 30793 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30794 30794 new_path="$unix_path"
30795 30795 fi
30796 30796
30797 30797 if test "x$path" != "x$new_path"; then
30798 30798 BUILD_JDK="$new_path"
30799 30799 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_JDK to \"$new_path\"" >&5
30800 30800 $as_echo "$as_me: Rewriting BUILD_JDK to \"$new_path\"" >&6;}
30801 30801 fi
30802 30802
30803 30803 # Save the first 10 bytes of this path to the storage, so fixpath can work.
30804 30804 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
30805 30805
30806 30806 else
30807 30807 # We're on a unix platform. Hooray! :)
30808 30808 path="$BUILD_JDK"
30809 30809 has_space=`$ECHO "$path" | $GREP " "`
30810 30810 if test "x$has_space" != x; then
30811 30811 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&5
30812 30812 $as_echo "$as_me: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&6;}
30813 30813 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
30814 30814 fi
30815 30815
30816 30816 # Use eval to expand a potential ~
30817 30817 eval path="$path"
30818 30818 if test ! -f "$path" && test ! -d "$path"; then
30819 30819 as_fn_error $? "The path of BUILD_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
30820 30820 fi
30821 30821
30822 30822 if test -d "$path"; then
30823 30823 BUILD_JDK="`cd "$path"; $THEPWDCMD -L`"
30824 30824 else
30825 30825 dir="`$DIRNAME "$path"`"
30826 30826 base="`$BASENAME "$path"`"
30827 30827 BUILD_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
30828 30828 fi
30829 30829 fi
30830 30830 fi
30831 30831
30832 30832 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
30833 30833 $as_echo_n "checking for Build JDK... " >&6; }
30834 30834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_JDK" >&5
30835 30835 $as_echo "$BUILD_JDK" >&6; }
30836 30836 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Build JDK version" >&5
30837 30837 $as_echo_n "checking Build JDK version... " >&6; }
30838 30838 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
30839 30839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_JDK_VERSION" >&5
30840 30840 $as_echo "$BUILD_JDK_VERSION" >&6; }
30841 30841 fi # end check jdk version
30842 30842 fi # end check java
30843 30843 fi # end check build jdk found
30844 30844 fi
30845 30845
30846 30846 EXTERNAL_BUILDJDK=true
30847 30847 else
30848 30848 if test "x$COMPILE_TYPE" = "xcross"; then
30849 30849 BUILD_JDK="\$(BUILDJDK_OUTPUTDIR)/jdk"
30850 30850 BUILD_JDK_FOUND=yes
30851 30851 CREATE_BUILDJDK=true
30852 30852 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
30853 30853 $as_echo_n "checking for Build JDK... " >&6; }
30854 30854 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, will build it for the host platform" >&5
30855 30855 $as_echo "yes, will build it for the host platform" >&6; }
30856 30856 else
30857 30857 BUILD_JDK="\$(JDK_OUTPUTDIR)"
30858 30858 BUILD_JDK_FOUND=yes
30859 30859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
30860 30860 $as_echo_n "checking for Build JDK... " >&6; }
30861 30861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, will use output dir" >&5
30862 30862 $as_echo "yes, will use output dir" >&6; }
30863 30863 fi
30864 30864 fi
30865 30865
30866 30866 JMOD="$BUILD_JDK/bin/jmod"
30867 30867 JLINK="$BUILD_JDK/bin/jlink"
30868 30868
30869 30869
30870 30870
30871 30871 if test "x$BUILD_JDK_FOUND" != "xyes"; then
30872 30872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
30873 30873 $as_echo_n "checking for Build JDK... " >&6; }
30874 30874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
30875 30875 $as_echo "no" >&6; }
30876 30876 as_fn_error $? "Could not find a suitable Build JDK" "$LINENO" 5
30877 30877 fi
30878 30878
30879 30879
30880 30880
30881 30881
30882 30882
30883 30883
30884 30884 ###############################################################################
30885 30885 #
30886 30886 # Configure the sources to use. We can add or override individual directories.
30887 30887 #
30888 30888 ###############################################################################
30889 30889
30890 30890
30891 30891 # Where are the sources.
30892 30892 LANGTOOLS_TOPDIR="$SRC_ROOT/langtools"
30893 30893 CORBA_TOPDIR="$SRC_ROOT/corba"
30894 30894 JAXP_TOPDIR="$SRC_ROOT/jaxp"
30895 30895 JAXWS_TOPDIR="$SRC_ROOT/jaxws"
30896 30896 HOTSPOT_TOPDIR="$SRC_ROOT/hotspot"
30897 30897 NASHORN_TOPDIR="$SRC_ROOT/nashorn"
30898 30898 JDK_TOPDIR="$SRC_ROOT/jdk"
30899 30899
30900 30900
30901 30901
30902 30902
30903 30903
30904 30904
30905 30905
30906 30906
30907 30907
30908 30908 # This feature is no longer supported.
30909 30909
30910 30910
30911 30911
30912 30912 # Check whether --with-add-source-root was given.
30913 30913 if test "${with_add_source_root+set}" = set; then :
30914 30914 withval=$with_add_source_root; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-add-source-root is deprecated and will be ignored." >&5
30915 30915 $as_echo "$as_me: WARNING: Option --with-add-source-root is deprecated and will be ignored." >&2;}
30916 30916 fi
30917 30917
30918 30918
30919 30919
30920 30920
30921 30921 # Check whether --with-override-source-root was given.
30922 30922 if test "${with_override_source_root+set}" = set; then :
30923 30923 withval=$with_override_source_root; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-source-root is deprecated and will be ignored." >&5
30924 30924 $as_echo "$as_me: WARNING: Option --with-override-source-root is deprecated and will be ignored." >&2;}
30925 30925 fi
30926 30926
30927 30927
30928 30928
30929 30929
30930 30930 # Check whether --with-adds-and-overrides was given.
30931 30931 if test "${with_adds_and_overrides+set}" = set; then :
30932 30932 withval=$with_adds_and_overrides; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-adds-and-overrides is deprecated and will be ignored." >&5
30933 30933 $as_echo "$as_me: WARNING: Option --with-adds-and-overrides is deprecated and will be ignored." >&2;}
30934 30934 fi
30935 30935
30936 30936
30937 30937
30938 30938
30939 30939 # Check whether --with-override-langtools was given.
30940 30940 if test "${with_override_langtools+set}" = set; then :
30941 30941 withval=$with_override_langtools; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-langtools is deprecated and will be ignored." >&5
30942 30942 $as_echo "$as_me: WARNING: Option --with-override-langtools is deprecated and will be ignored." >&2;}
30943 30943 fi
30944 30944
30945 30945
30946 30946
30947 30947
30948 30948 # Check whether --with-override-corba was given.
30949 30949 if test "${with_override_corba+set}" = set; then :
30950 30950 withval=$with_override_corba; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-corba is deprecated and will be ignored." >&5
30951 30951 $as_echo "$as_me: WARNING: Option --with-override-corba is deprecated and will be ignored." >&2;}
30952 30952 fi
30953 30953
30954 30954
30955 30955
30956 30956
30957 30957 # Check whether --with-override-jaxp was given.
30958 30958 if test "${with_override_jaxp+set}" = set; then :
30959 30959 withval=$with_override_jaxp; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jaxp is deprecated and will be ignored." >&5
30960 30960 $as_echo "$as_me: WARNING: Option --with-override-jaxp is deprecated and will be ignored." >&2;}
30961 30961 fi
30962 30962
30963 30963
30964 30964
30965 30965
30966 30966 # Check whether --with-override-jaxws was given.
30967 30967 if test "${with_override_jaxws+set}" = set; then :
30968 30968 withval=$with_override_jaxws; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jaxws is deprecated and will be ignored." >&5
30969 30969 $as_echo "$as_me: WARNING: Option --with-override-jaxws is deprecated and will be ignored." >&2;}
30970 30970 fi
30971 30971
30972 30972
30973 30973
30974 30974
30975 30975 # Check whether --with-override-hotspot was given.
30976 30976 if test "${with_override_hotspot+set}" = set; then :
30977 30977 withval=$with_override_hotspot; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-hotspot is deprecated and will be ignored." >&5
30978 30978 $as_echo "$as_me: WARNING: Option --with-override-hotspot is deprecated and will be ignored." >&2;}
30979 30979 fi
30980 30980
30981 30981
30982 30982
30983 30983
30984 30984 # Check whether --with-override-nashorn was given.
30985 30985 if test "${with_override_nashorn+set}" = set; then :
30986 30986 withval=$with_override_nashorn; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-nashorn is deprecated and will be ignored." >&5
30987 30987 $as_echo "$as_me: WARNING: Option --with-override-nashorn is deprecated and will be ignored." >&2;}
30988 30988 fi
30989 30989
30990 30990
30991 30991
30992 30992
30993 30993 # Check whether --with-override-jdk was given.
30994 30994 if test "${with_override_jdk+set}" = set; then :
30995 30995 withval=$with_override_jdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jdk is deprecated and will be ignored." >&5
30996 30996 $as_echo "$as_me: WARNING: Option --with-override-jdk is deprecated and will be ignored." >&2;}
30997 30997 fi
30998 30998
30999 30999
31000 31000
31001 31001
31002 31002 BUILD_OUTPUT="$OUTPUT_ROOT"
31003 31003
31004 31004
31005 31005 HOTSPOT_DIST="$OUTPUT_ROOT/hotspot/dist"
31006 31006 BUILD_HOTSPOT=true
31007 31007
31008 31008
31009 31009
31010 31010 # Check whether --with-import-hotspot was given.
31011 31011 if test "${with_import_hotspot+set}" = set; then :
31012 31012 withval=$with_import_hotspot;
31013 31013 fi
31014 31014
31015 31015 if test "x$with_import_hotspot" != x; then
31016 31016 CURDIR="$PWD"
31017 31017 cd "$with_import_hotspot"
31018 31018 HOTSPOT_DIST="`pwd`"
31019 31019 cd "$CURDIR"
31020 31020 if ! (test -d $HOTSPOT_DIST/lib && test -d $HOTSPOT_DIST/jre/lib); then
31021 31021 as_fn_error $? "You have to import hotspot from a full jdk image or hotspot build dist dir!" "$LINENO" 5
31022 31022 fi
31023 31023 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be imported" >&5
31024 31024 $as_echo_n "checking if hotspot should be imported... " >&6; }
31025 31025 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes from $HOTSPOT_DIST" >&5
31026 31026 $as_echo "yes from $HOTSPOT_DIST" >&6; }
31027 31027 BUILD_HOTSPOT=false
31028 31028 fi
31029 31029
31030 31030 JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk"
31031 31031
31032 31032
31033 31033
31034 31034
31035 31035 # Check whether --with-import-modules was given.
31036 31036 if test "${with_import_modules+set}" = set; then :
31037 31037 withval=$with_import_modules;
31038 31038 fi
31039 31039
31040 31040
31041 31041 if test "x$with_import_modules" != x \
31042 31042 && test "x$with_import_modules" != "xno"; then
31043 31043 if test -d "$with_import_modules"; then
31044 31044 IMPORT_MODULES_TOPDIR="$with_import_modules"
31045 31045
31046 31046 # Only process if variable expands to non-empty
31047 31047
31048 31048 if test "x$IMPORT_MODULES_TOPDIR" != x; then
31049 31049 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31050 31050
31051 31051 # Input might be given as Windows format, start by converting to
31052 31052 # unix format.
31053 31053 path="$IMPORT_MODULES_TOPDIR"
31054 31054 new_path=`$CYGPATH -u "$path"`
31055 31055
31056 31056 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
31057 31057 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
31058 31058 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
31059 31059 # "foo.exe" is OK but "foo" is an error.
31060 31060 #
31061 31061 # This test is therefore slightly more accurate than "test -f" to check for file precense.
31062 31062 # It is also a way to make sure we got the proper file name for the real test later on.
31063 31063 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
31064 31064 if test "x$test_shortpath" = x; then
31065 31065 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&5
31066 31066 $as_echo "$as_me: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&6;}
31067 31067 as_fn_error $? "Cannot locate the the path of IMPORT_MODULES_TOPDIR" "$LINENO" 5
31068 31068 fi
31069 31069
31070 31070 # Call helper function which possibly converts this using DOS-style short mode.
31071 31071 # If so, the updated path is stored in $new_path.
31072 31072
31073 31073 input_path="$new_path"
31074 31074 # Check if we need to convert this using DOS-style short mode. If the path
31075 31075 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31076 31076 # take no chances and rewrite it.
31077 31077 # Note: m4 eats our [], so we need to use [ and ] instead.
31078 31078 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
31079 31079 if test "x$has_forbidden_chars" != x; then
31080 31080 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31081 31081 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
31082 31082 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
31083 31083 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
31084 31084 # Going to short mode and back again did indeed matter. Since short mode is
31085 31085 # case insensitive, let's make it lowercase to improve readability.
31086 31086 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31087 31087 # Now convert it back to Unix-style (cygpath)
31088 31088 input_path=`$CYGPATH -u "$shortmode_path"`
31089 31089 new_path="$input_path"
31090 31090 fi
31091 31091 fi
31092 31092
31093 31093 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
31094 31094 if test "x$test_cygdrive_prefix" = x; then
31095 31095 # As a simple fix, exclude /usr/bin since it's not a real path.
31096 31096 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
31097 31097 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
31098 31098 # a path prefixed by /cygdrive for fixpath to work.
31099 31099 new_path="$CYGWIN_ROOT_PATH$input_path"
31100 31100 fi
31101 31101 fi
31102 31102
31103 31103
31104 31104 if test "x$path" != "x$new_path"; then
31105 31105 IMPORT_MODULES_TOPDIR="$new_path"
31106 31106 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&5
31107 31107 $as_echo "$as_me: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&6;}
31108 31108 fi
31109 31109
31110 31110 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31111 31111
31112 31112 path="$IMPORT_MODULES_TOPDIR"
31113 31113 has_colon=`$ECHO $path | $GREP ^.:`
31114 31114 new_path="$path"
31115 31115 if test "x$has_colon" = x; then
31116 31116 # Not in mixed or Windows style, start by that.
31117 31117 new_path=`cmd //c echo $path`
31118 31118 fi
31119 31119
31120 31120
31121 31121 input_path="$new_path"
31122 31122 # Check if we need to convert this using DOS-style short mode. If the path
31123 31123 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31124 31124 # take no chances and rewrite it.
31125 31125 # Note: m4 eats our [], so we need to use [ and ] instead.
31126 31126 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
31127 31127 if test "x$has_forbidden_chars" != x; then
31128 31128 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31129 31129 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31130 31130 fi
31131 31131
31132 31132
31133 31133 windows_path="$new_path"
31134 31134 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31135 31135 unix_path=`$CYGPATH -u "$windows_path"`
31136 31136 new_path="$unix_path"
31137 31137 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31138 31138 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31139 31139 new_path="$unix_path"
31140 31140 fi
31141 31141
31142 31142 if test "x$path" != "x$new_path"; then
31143 31143 IMPORT_MODULES_TOPDIR="$new_path"
31144 31144 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&5
31145 31145 $as_echo "$as_me: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&6;}
31146 31146 fi
31147 31147
31148 31148 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31149 31149 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31150 31150
31151 31151 else
31152 31152 # We're on a unix platform. Hooray! :)
31153 31153 path="$IMPORT_MODULES_TOPDIR"
31154 31154 has_space=`$ECHO "$path" | $GREP " "`
31155 31155 if test "x$has_space" != x; then
31156 31156 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&5
31157 31157 $as_echo "$as_me: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&6;}
31158 31158 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
31159 31159 fi
31160 31160
31161 31161 # Use eval to expand a potential ~
31162 31162 eval path="$path"
31163 31163 if test ! -f "$path" && test ! -d "$path"; then
31164 31164 as_fn_error $? "The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
31165 31165 fi
31166 31166
31167 31167 if test -d "$path"; then
31168 31168 IMPORT_MODULES_TOPDIR="`cd "$path"; $THEPWDCMD -L`"
31169 31169 else
31170 31170 dir="`$DIRNAME "$path"`"
31171 31171 base="`$BASENAME "$path"`"
31172 31172 IMPORT_MODULES_TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
31173 31173 fi
31174 31174 fi
31175 31175 fi
31176 31176
31177 31177 elif test -e "$with_import_modules"; then
31178 31178 IMPORT_MODULES_TOPDIR="$CONFIGURESUPPORT_OUTPUTDIR/import-modules"
31179 31179 $RM -rf "$IMPORT_MODULES_TOPDIR"
31180 31180 $MKDIR -p "$IMPORT_MODULES_TOPDIR"
31181 31181 if ! $UNZIP -q "$with_import_modules" -d "$IMPORT_MODULES_TOPDIR"; then
31182 31182 as_fn_error $? "--with-import-modules=\"$with_import_modules\" must point to a dir or a zip file" "$LINENO" 5
31183 31183 fi
31184 31184 else
31185 31185 as_fn_error $? "--with-import-modules=\"$with_import_modules\" must point to a dir or a zip file" "$LINENO" 5
31186 31186 fi
31187 31187 fi
31188 31188
31189 31189 if test -d "$IMPORT_MODULES_TOPDIR/modules"; then
31190 31190 IMPORT_MODULES_CLASSES="$IMPORT_MODULES_TOPDIR/modules"
31191 31191 fi
31192 31192 if test -d "$IMPORT_MODULES_TOPDIR/modules_cmds"; then
31193 31193 IMPORT_MODULES_CMDS="$IMPORT_MODULES_TOPDIR/modules_cmds"
31194 31194 fi
31195 31195 if test -d "$IMPORT_MODULES_TOPDIR/modules_libs"; then
31196 31196 IMPORT_MODULES_LIBS="$IMPORT_MODULES_TOPDIR/modules_libs"
31197 31197 fi
31198 31198 if test -d "$IMPORT_MODULES_TOPDIR/modules_conf"; then
31199 31199 IMPORT_MODULES_CONF="$IMPORT_MODULES_TOPDIR/modules_conf"
31200 31200 fi
31201 31201 if test -d "$IMPORT_MODULES_TOPDIR/modules_src"; then
31202 31202 IMPORT_MODULES_SRC="$IMPORT_MODULES_TOPDIR/modules_src"
31203 31203 fi
31204 31204 if test -d "$IMPORT_MODULES_TOPDIR/make"; then
31205 31205 IMPORT_MODULES_MAKE="$IMPORT_MODULES_TOPDIR/make"
31206 31206 fi
31207 31207
31208 31208
31209 31209
31210 31210
31211 31211
31212 31212
31213 31213
31214 31214
31215 31215
31216 31216 ###############################################################################
31217 31217 #
31218 31218 # Setup the toolchain (compilers etc), i.e. tools used to compile and process
31219 31219 # native code.
31220 31220 #
31221 31221 ###############################################################################
31222 31222
31223 31223 # See if we are doing a complete static build or not
31224 31224
31225 31225 # Check whether --enable-static-build was given.
31226 31226 if test "${enable_static_build+set}" = set; then :
31227 31227 enableval=$enable_static_build;
31228 31228 fi
31229 31229
31230 31230 STATIC_BUILD=false
31231 31231 if test "x$enable_static_build" = "xyes"; then
31232 31232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static build is enabled" >&5
31233 31233 $as_echo_n "checking if static build is enabled... " >&6; }
31234 31234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
31235 31235 $as_echo "yes" >&6; }
31236 31236 if test "x$OPENJDK_TARGET_OS" != "xmacosx"; then
31237 31237 as_fn_error $? "--enable-static-build is only supported for macosx builds" "$LINENO" 5
31238 31238 fi
31239 31239 STATIC_BUILD_CFLAGS="-DSTATIC_BUILD=1"
31240 31240 LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $STATIC_BUILD_CFLAGS"
31241 31241 LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $STATIC_BUILD_CFLAGS"
31242 31242 CFLAGS_JDKLIB_EXTRA="$CFLAGS_JDKLIB_EXTRA $STATIC_BUILD_CFLAGS"
31243 31243 CXXFLAGS_JDKLIB_EXTRA="$CXXFLAGS_JDKLIB_EXTRA $STATIC_BUILD_CFLAGS"
31244 31244 STATIC_BUILD=true
31245 31245 elif test "x$enable_static_build" = "xno"; then
31246 31246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static build is enabled" >&5
31247 31247 $as_echo_n "checking if static build is enabled... " >&6; }
31248 31248 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31249 31249 $as_echo "no" >&6; }
31250 31250 elif test "x$enable_static_build" != "x"; then
31251 31251 as_fn_error $? "--enable-static-build can only be assigned \"yes\" or \"no\"" "$LINENO" 5
31252 31252 fi
31253 31253
31254 31254
31255 31255
31256 31256
31257 31257 # First determine the toolchain type (compiler family)
31258 31258
31259 31259
31260 31260 # Check whether --with-toolchain-type was given.
31261 31261 if test "${with_toolchain_type+set}" = set; then :
31262 31262 withval=$with_toolchain_type;
31263 31263 fi
31264 31264
31265 31265
31266 31266 # Use indirect variable referencing
31267 31267 toolchain_var_name=VALID_TOOLCHAINS_$OPENJDK_BUILD_OS
31268 31268 VALID_TOOLCHAINS=${!toolchain_var_name}
31269 31269
31270 31270 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
31271 31271 if test -n "$XCODEBUILD"; then
31272 31272 # On Mac OS X, default toolchain to clang after Xcode 5
31273 31273 XCODE_VERSION_OUTPUT=`"$XCODEBUILD" -version 2>&1 | $HEAD -n 1`
31274 31274 $ECHO "$XCODE_VERSION_OUTPUT" | $GREP "Xcode " > /dev/null
31275 31275 if test $? -ne 0; then
31276 31276 as_fn_error $? "Failed to determine Xcode version." "$LINENO" 5
31277 31277 fi
31278 31278 XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
31279 31279 $SED -e 's/^Xcode \([1-9][0-9.]*\)/\1/' | \
31280 31280 $CUT -f 1 -d .`
31281 31281 { $as_echo "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
31282 31282 $as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
31283 31283 if test $XCODE_MAJOR_VERSION -ge 5; then
31284 31284 DEFAULT_TOOLCHAIN="clang"
31285 31285 else
31286 31286 DEFAULT_TOOLCHAIN="gcc"
31287 31287 fi
31288 31288 else
31289 31289 # If Xcode is not installed, but the command line tools are
31290 31290 # then we can't run xcodebuild. On these systems we should
31291 31291 # default to clang
31292 31292 DEFAULT_TOOLCHAIN="clang"
31293 31293 fi
31294 31294 else
31295 31295 # First toolchain type in the list is the default
31296 31296 DEFAULT_TOOLCHAIN=${VALID_TOOLCHAINS%% *}
31297 31297 fi
31298 31298
31299 31299 if test "x$with_toolchain_type" = xlist; then
31300 31300 # List all toolchains
31301 31301 { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
31302 31302 $as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
31303 31303 for toolchain in $VALID_TOOLCHAINS; do
31304 31304 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
31305 31305 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
31306 31306 $PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
31307 31307 done
31308 31308
31309 31309 exit 0
31310 31310 elif test "x$with_toolchain_type" != x; then
31311 31311 # User override; check that it is valid
31312 31312 if test "x${VALID_TOOLCHAINS/$with_toolchain_type/}" = "x${VALID_TOOLCHAINS}"; then
31313 31313 { $as_echo "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
31314 31314 $as_echo "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
31315 31315 { $as_echo "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
31316 31316 $as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
31317 31317 as_fn_error $? "Cannot continue." "$LINENO" 5
31318 31318 fi
31319 31319 TOOLCHAIN_TYPE=$with_toolchain_type
31320 31320 else
31321 31321 # No flag given, use default
31322 31322 TOOLCHAIN_TYPE=$DEFAULT_TOOLCHAIN
31323 31323 fi
31324 31324
31325 31325
31326 31326 TOOLCHAIN_CC_BINARY_clang="clang"
31327 31327 TOOLCHAIN_CC_BINARY_gcc="gcc"
31328 31328 TOOLCHAIN_CC_BINARY_microsoft="cl"
31329 31329 TOOLCHAIN_CC_BINARY_solstudio="cc"
31330 31330 TOOLCHAIN_CC_BINARY_xlc="xlc_r"
31331 31331
31332 31332 TOOLCHAIN_CXX_BINARY_clang="clang++"
31333 31333 TOOLCHAIN_CXX_BINARY_gcc="g++"
31334 31334 TOOLCHAIN_CXX_BINARY_microsoft="cl"
31335 31335 TOOLCHAIN_CXX_BINARY_solstudio="CC"
31336 31336 TOOLCHAIN_CXX_BINARY_xlc="xlC_r"
31337 31337
31338 31338 # Use indirect variable referencing
31339 31339 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$TOOLCHAIN_TYPE
31340 31340 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
31341 31341 toolchain_var_name=TOOLCHAIN_MINIMUM_VERSION_$TOOLCHAIN_TYPE
31342 31342 TOOLCHAIN_MINIMUM_VERSION=${!toolchain_var_name}
31343 31343 toolchain_var_name=TOOLCHAIN_CC_BINARY_$TOOLCHAIN_TYPE
31344 31344 TOOLCHAIN_CC_BINARY=${!toolchain_var_name}
31345 31345 toolchain_var_name=TOOLCHAIN_CXX_BINARY_$TOOLCHAIN_TYPE
31346 31346 TOOLCHAIN_CXX_BINARY=${!toolchain_var_name}
31347 31347
31348 31348
31349 31349 # Define filename patterns
31350 31350 if test "x$OPENJDK_TARGET_OS" = xwindows; then
31351 31351 LIBRARY_PREFIX=
31352 31352 SHARED_LIBRARY_SUFFIX='.dll'
31353 31353 STATIC_LIBRARY_SUFFIX='.lib'
31354 31354 SHARED_LIBRARY='$1.dll'
31355 31355 STATIC_LIBRARY='$1.lib'
31356 31356 OBJ_SUFFIX='.obj'
31357 31357 EXE_SUFFIX='.exe'
31358 31358 else
31359 31359 LIBRARY_PREFIX=lib
31360 31360 SHARED_LIBRARY_SUFFIX='.so'
31361 31361 STATIC_LIBRARY_SUFFIX='.a'
31362 31362 SHARED_LIBRARY='lib$1.so'
31363 31363 STATIC_LIBRARY='lib$1.a'
31364 31364 OBJ_SUFFIX='.o'
31365 31365 EXE_SUFFIX=''
31366 31366 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
31367 31367 # For full static builds, we're overloading the SHARED_LIBRARY
31368 31368 # variables in order to limit the amount of changes required.
31369 31369 # It would be better to remove SHARED and just use LIBRARY and
31370 31370 # LIBRARY_SUFFIX for libraries that can be built either
31371 31371 # shared or static and use STATIC_* for libraries that are
31372 31372 # always built statically.
31373 31373 if test "x$STATIC_BUILD" = xtrue; then
31374 31374 SHARED_LIBRARY='lib$1.a'
31375 31375 SHARED_LIBRARY_SUFFIX='.a'
31376 31376 else
31377 31377 SHARED_LIBRARY='lib$1.dylib'
31378 31378 SHARED_LIBRARY_SUFFIX='.dylib'
31379 31379 fi
31380 31380 fi
31381 31381 fi
31382 31382
31383 31383
31384 31384
31385 31385
31386 31386
31387 31387
31388 31388
31389 31389
31390 31390
31391 31391
31392 31392 if test "x$TOOLCHAIN_TYPE" = "x$DEFAULT_TOOLCHAIN"; then
31393 31393 { $as_echo "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
31394 31394 $as_echo "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
31395 31395 else
31396 31396 { $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
31397 31397 $as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
31398 31398 fi
31399 31399
31400 31400
31401 31401 # User supplied flags should be used when configure detects compilers
31402 31402
31403 31403 if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
31404 31404 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
31405 31405 $as_echo "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
31406 31406 fi
31407 31407
31408 31408 if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
31409 31409 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
31410 31410 $as_echo "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
31411 31411 fi
31412 31412
31413 31413 if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
31414 31414 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
31415 31415 $as_echo "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
31416 31416 fi
31417 31417
31418 31418
31419 31419 # Check whether --with-extra-cflags was given.
31420 31420 if test "${with_extra_cflags+set}" = set; then :
31421 31421 withval=$with_extra_cflags;
31422 31422 fi
31423 31423
31424 31424
31425 31425
31426 31426 # Check whether --with-extra-cxxflags was given.
31427 31427 if test "${with_extra_cxxflags+set}" = set; then :
31428 31428 withval=$with_extra_cxxflags;
31429 31429 fi
31430 31430
31431 31431
31432 31432
31433 31433 # Check whether --with-extra-ldflags was given.
31434 31434 if test "${with_extra_ldflags+set}" = set; then :
31435 31435 withval=$with_extra_ldflags;
31436 31436 fi
31437 31437
31438 31438
31439 31439 EXTRA_CFLAGS="$with_extra_cflags"
31440 31440 EXTRA_CXXFLAGS="$with_extra_cxxflags"
31441 31441 EXTRA_LDFLAGS="$with_extra_ldflags"
31442 31442
31443 31443 # Hotspot needs these set in their legacy form
31444 31444 LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $EXTRA_CFLAGS"
31445 31445 LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $EXTRA_CXXFLAGS"
31446 31446 LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $EXTRA_LDFLAGS"
31447 31447
31448 31448
31449 31449
31450 31450
31451 31451
31452 31452
31453 31453
31454 31454
31455 31455
31456 31456 # The global CFLAGS and LDLAGS variables are used by configure tests and
31457 31457 # should include the extra parameters
31458 31458 CFLAGS="$EXTRA_CFLAGS"
31459 31459 CXXFLAGS="$EXTRA_CXXFLAGS"
31460 31460 LDFLAGS="$EXTRA_LDFLAGS"
31461 31461 CPPFLAGS=""
31462 31462
31463 31463 # The sysroot cflags are needed for configure to be able to run the compilers
31464 31464
31465 31465 if test "x$SYSROOT" != "x"; then
31466 31466 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
31467 31467 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
31468 31468 # Solaris Studio does not have a concept of sysroot. Instead we must
31469 31469 # make sure the default include and lib dirs are appended to each
31470 31470 # compile and link command line. Must also add -I-xbuiltin to enable
31471 31471 # inlining of system functions and intrinsics.
31472 31472 SYSROOT_CFLAGS="-I-xbuiltin -I$SYSROOT/usr/include"
31473 31473 SYSROOT_LDFLAGS="-L$SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
31474 31474 -L$SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR \
31475 31475 -L$SYSROOT/usr/ccs/lib$OPENJDK_TARGET_CPU_ISADIR"
31476 31476 fi
31477 31477 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
31478 31478 SYSROOT_CFLAGS="--sysroot=$SYSROOT"
31479 31479 SYSROOT_LDFLAGS="--sysroot=$SYSROOT"
31480 31480 elif test "x$TOOLCHAIN_TYPE" = xclang; then
31481 31481 SYSROOT_CFLAGS="-isysroot $SYSROOT"
31482 31482 SYSROOT_LDFLAGS="-isysroot $SYSROOT"
31483 31483 fi
31484 31484 # Propagate the sysroot args to hotspot
31485 31485 LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $SYSROOT_CFLAGS"
31486 31486 LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $SYSROOT_CFLAGS"
31487 31487 LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $SYSROOT_LDFLAGS"
31488 31488 # The global CFLAGS and LDFLAGS variables need these for configure to function
31489 31489 CFLAGS="$CFLAGS $SYSROOT_CFLAGS"
31490 31490 CPPFLAGS="$CPPFLAGS $SYSROOT_CFLAGS"
31491 31491 CXXFLAGS="$CXXFLAGS $SYSROOT_CFLAGS"
31492 31492 LDFLAGS="$LDFLAGS $SYSROOT_LDFLAGS"
31493 31493 fi
31494 31494
31495 31495 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
31496 31496 # We also need -iframework<path>/System/Library/Frameworks
31497 31497 SYSROOT_CFLAGS="$SYSROOT_CFLAGS -iframework $SYSROOT/System/Library/Frameworks"
31498 31498 SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -iframework $SYSROOT/System/Library/Frameworks"
31499 31499 # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
31500 31500 # set this here so it doesn't have to be peppered throughout the forest
31501 31501 SYSROOT_CFLAGS="$SYSROOT_CFLAGS -F $SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
31502 31502 SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -F $SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
31503 31503 fi
31504 31504
31505 31505
31506 31506
31507 31507
31508 31508
31509 31509 # Then detect the actual binaries needed
31510 31510
31511 31511 # FIXME: Is this needed?
31512 31512 ac_ext=cpp
31513 31513 ac_cpp='$CXXCPP $CPPFLAGS'
31514 31514 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
31515 31515 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
31516 31516 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
31517 31517
31518 31518
31519 31519 # Store the CFLAGS etc passed to the configure script.
31520 31520 ORG_CFLAGS="$CFLAGS"
31521 31521 ORG_CXXFLAGS="$CXXFLAGS"
31522 31522
31523 31523 # autoconf magic only relies on PATH, so update it if tools dir is specified
31524 31524 OLD_PATH="$PATH"
31525 31525
31526 31526 # On Windows, we need to detect the visual studio installation first.
31527 31527 # This will change the PATH, but we need to keep that new PATH even
31528 31528 # after toolchain detection is done, since the compiler (on x86) uses
31529 31529 # it for DLL resolution in runtime.
31530 31530 if test "x$OPENJDK_BUILD_OS" = "xwindows" \
31531 31531 && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
31532 31532
31533 31533 # Store path to cygwin link.exe to help excluding it when searching for
31534 31534 # VS linker. This must be done before changing the PATH when looking for VS.
31535 31535 # Extract the first word of "link", so it can be a program name with args.
31536 31536 set dummy link; ac_word=$2
31537 31537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
31538 31538 $as_echo_n "checking for $ac_word... " >&6; }
31539 31539 if ${ac_cv_path_CYGWIN_LINK+:} false; then :
31540 31540 $as_echo_n "(cached) " >&6
31541 31541 else
31542 31542 case $CYGWIN_LINK in
31543 31543 [\\/]* | ?:[\\/]*)
31544 31544 ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
31545 31545 ;;
31546 31546 *)
31547 31547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
31548 31548 for as_dir in $PATH
31549 31549 do
31550 31550 IFS=$as_save_IFS
31551 31551 test -z "$as_dir" && as_dir=.
31552 31552 for ac_exec_ext in '' $ac_executable_extensions; do
31553 31553 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
31554 31554 ac_cv_path_CYGWIN_LINK="$as_dir/$ac_word$ac_exec_ext"
31555 31555 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
31556 31556 break 2
31557 31557 fi
31558 31558 done
31559 31559 done
31560 31560 IFS=$as_save_IFS
31561 31561
31562 31562 ;;
31563 31563 esac
31564 31564 fi
31565 31565 CYGWIN_LINK=$ac_cv_path_CYGWIN_LINK
31566 31566 if test -n "$CYGWIN_LINK"; then
31567 31567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
31568 31568 $as_echo "$CYGWIN_LINK" >&6; }
31569 31569 else
31570 31570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31571 31571 $as_echo "no" >&6; }
31572 31572 fi
31573 31573
31574 31574
31575 31575 if test "x$CYGWIN_LINK" != x; then
31576 31576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
31577 31577 $as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
31578 31578 "$CYGWIN_LINK" --version > /dev/null
31579 31579 if test $? -eq 0 ; then
31580 31580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
31581 31581 $as_echo "yes" >&6; }
31582 31582 else
31583 31583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
31584 31584 $as_echo "no" >&6; }
31585 31585 # This might be the VS linker. Don't exclude it later on.
31586 31586 CYGWIN_LINK=""
31587 31587 fi
31588 31588 fi
31589 31589
31590 31590 # First-hand choice is to locate and run the vsvars bat file.
31591 31591
31592 31592
31593 31593 # Check whether --with-toolchain-version was given.
31594 31594 if test "${with_toolchain_version+set}" = set; then :
31595 31595 withval=$with_toolchain_version;
31596 31596 fi
31597 31597
31598 31598
31599 31599 if test "x$with_toolchain_version" = xlist; then
31600 31600 # List all toolchains
31601 31601 { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
31602 31602 $as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
31603 31603 for version in $VALID_VS_VERSIONS; do
31604 31604 eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
31605 31605 $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
31606 31606 done
31607 31607
31608 31608 exit 0
31609 31609 elif test "x$DEVKIT_VS_VERSION" != x; then
31610 31610 VS_VERSION=$DEVKIT_VS_VERSION
31611 31611 TOOLCHAIN_VERSION=$VS_VERSION
31612 31612 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
31613 31613 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
31614 31614 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
31615 31615 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
31616 31616 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31617 31617 VS_PATH="$TOOLCHAIN_PATH:$PATH"
31618 31618
31619 31619 # Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it
31620 31620 # can still be exported as INCLUDE for compiler invocations without
31621 31621 # SYSROOT_CFLAGS
31622 31622 OLDIFS="$IFS"
31623 31623 IFS=";"
31624 31624 for i in $DEVKIT_VS_INCLUDE; do
31625 31625 ipath=$i
31626 31626
31627 31627 unix_path="$ipath"
31628 31628 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31629 31629 windows_path=`$CYGPATH -m "$unix_path"`
31630 31630 ipath="$windows_path"
31631 31631 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31632 31632 windows_path=`cmd //c echo $unix_path`
31633 31633 ipath="$windows_path"
31634 31634 fi
31635 31635
31636 31636 VS_INCLUDE="$VS_INCLUDE;$ipath"
31637 31637 done
31638 31638 # Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported
31639 31639 # as LIB for compiler invocations without SYSROOT_LDFLAGS
31640 31640 for i in $DEVKIT_VS_LIB; do
31641 31641 libpath=$i
31642 31642
31643 31643 unix_path="$libpath"
31644 31644 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31645 31645 windows_path=`$CYGPATH -m "$unix_path"`
31646 31646 libpath="$windows_path"
31647 31647 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31648 31648 windows_path=`cmd //c echo $unix_path`
31649 31649 libpath="$windows_path"
31650 31650 fi
31651 31651
31652 31652 VS_LIB="$VS_LIB;$libpath"
31653 31653 done
31654 31654 IFS="$OLDIFS"
31655 31655
31656 31656 { $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
31657 31657 $as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
31658 31658
31659 31659 elif test "x$with_toolchain_version" != x; then
31660 31660 # User override; check that it is valid
31661 31661 if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
31662 31662 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
31663 31663 $as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
31664 31664 { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
31665 31665 $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
31666 31666 as_fn_error $? "Cannot continue." "$LINENO" 5
31667 31667 fi
31668 31668 VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
31669 31669 else
31670 31670 # No flag given, use default
31671 31671 VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
31672 31672 fi
31673 31673
31674 31674 for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
31675 31675
31676 31676 VS_VERSION="$VS_VERSION"
31677 31677 eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
31678 31678 eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
31679 31679 eval VS_INSTALL_DIR="\${VS_VS_INSTALLDIR_${VS_VERSION}}"
31680 31680 eval SDK_INSTALL_DIR="\${VS_SDK_INSTALLDIR_${VS_VERSION}}"
31681 31681
31682 31682 # When using --with-tools-dir, assume it points to the correct and default
31683 31683 # version of Visual Studio or that --with-toolchain-version was also set.
31684 31684 if test "x$with_tools_dir" != x; then
31685 31685
31686 31686 if test "x$VS_ENV_CMD" = x; then
31687 31687 VS_VERSION="${VS_VERSION}"
31688 31688 VS_BASE="$with_tools_dir/../.."
31689 31689 METHOD="--with-tools-dir"
31690 31690
31691 31691 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31692 31692 VCVARSFILE="vc/bin/vcvars32.bat"
31693 31693 else
31694 31694 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31695 31695 fi
31696 31696
31697 31697
31698 31698 windows_path="$VS_BASE"
31699 31699 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31700 31700 unix_path=`$CYGPATH -u "$windows_path"`
31701 31701 VS_BASE="$unix_path"
31702 31702 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31703 31703 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31704 31704 VS_BASE="$unix_path"
31705 31705 fi
31706 31706
31707 31707 if test -d "$VS_BASE"; then
31708 31708 if test -f "$VS_BASE/$VCVARSFILE"; then
31709 31709 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31710 31710 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31711 31711 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31712 31712 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31713 31713 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31714 31714 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31715 31715 else
31716 31716 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31717 31717 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31718 31718 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31719 31719 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31720 31720 fi
31721 31721 fi
31722 31722 fi
31723 31723
31724 31724
31725 31725 if test "x$VS_ENV_CMD" = x; then
31726 31726 VS_VERSION="${VS_VERSION}"
31727 31727 VS_BASE="$with_tools_dir/../../.."
31728 31728 METHOD="--with-tools-dir"
31729 31729
31730 31730 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31731 31731 VCVARSFILE="vc/bin/vcvars32.bat"
31732 31732 else
31733 31733 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31734 31734 fi
31735 31735
31736 31736
31737 31737 windows_path="$VS_BASE"
31738 31738 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31739 31739 unix_path=`$CYGPATH -u "$windows_path"`
31740 31740 VS_BASE="$unix_path"
31741 31741 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31742 31742 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31743 31743 VS_BASE="$unix_path"
31744 31744 fi
31745 31745
31746 31746 if test -d "$VS_BASE"; then
31747 31747 if test -f "$VS_BASE/$VCVARSFILE"; then
31748 31748 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31749 31749 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31750 31750 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31751 31751 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31752 31752 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31753 31753 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31754 31754 else
31755 31755 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31756 31756 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31757 31757 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31758 31758 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31759 31759 fi
31760 31760 fi
31761 31761 fi
31762 31762
31763 31763 if test "x$VS_ENV_CMD" = x; then
31764 31764 # Having specified an argument which is incorrect will produce an instant failure;
31765 31765 # we should not go on looking
31766 31766 { $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
31767 31767 $as_echo "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
31768 31768 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
31769 31769 $as_echo "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
31770 31770 { $as_echo "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
31771 31771 $as_echo "$as_me: directory within the Visual Studio installation" >&6;}
31772 31772 as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
31773 31773 fi
31774 31774 fi
31775 31775
31776 31776 VS_ENV_CMD=""
31777 31777 VS_ENV_ARGS=""
31778 31778
31779 31779 if test "x$VS_COMNTOOLS" != x; then
31780 31780
31781 31781 if test "x$VS_ENV_CMD" = x; then
31782 31782 VS_VERSION="${VS_VERSION}"
31783 31783 VS_BASE="$VS_COMNTOOLS/../.."
31784 31784 METHOD="$VS_COMNTOOLS_VAR variable"
31785 31785
31786 31786 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31787 31787 VCVARSFILE="vc/bin/vcvars32.bat"
31788 31788 else
31789 31789 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31790 31790 fi
31791 31791
31792 31792
31793 31793 windows_path="$VS_BASE"
31794 31794 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31795 31795 unix_path=`$CYGPATH -u "$windows_path"`
31796 31796 VS_BASE="$unix_path"
31797 31797 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31798 31798 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31799 31799 VS_BASE="$unix_path"
31800 31800 fi
31801 31801
31802 31802 if test -d "$VS_BASE"; then
31803 31803 if test -f "$VS_BASE/$VCVARSFILE"; then
31804 31804 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31805 31805 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31806 31806 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31807 31807 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31808 31808 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31809 31809 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31810 31810 else
31811 31811 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31812 31812 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31813 31813 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31814 31814 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31815 31815 fi
31816 31816 fi
31817 31817 fi
31818 31818
31819 31819 fi
31820 31820 if test "x$PROGRAMFILES" != x; then
31821 31821
31822 31822 if test "x$VS_ENV_CMD" = x; then
31823 31823 VS_VERSION="${VS_VERSION}"
31824 31824 VS_BASE="$PROGRAMFILES/$VS_INSTALL_DIR"
31825 31825 METHOD="well-known name"
31826 31826
31827 31827 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31828 31828 VCVARSFILE="vc/bin/vcvars32.bat"
31829 31829 else
31830 31830 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31831 31831 fi
31832 31832
31833 31833
31834 31834 windows_path="$VS_BASE"
31835 31835 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31836 31836 unix_path=`$CYGPATH -u "$windows_path"`
31837 31837 VS_BASE="$unix_path"
31838 31838 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31839 31839 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31840 31840 VS_BASE="$unix_path"
31841 31841 fi
31842 31842
31843 31843 if test -d "$VS_BASE"; then
31844 31844 if test -f "$VS_BASE/$VCVARSFILE"; then
31845 31845 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31846 31846 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31847 31847 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31848 31848 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31849 31849 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31850 31850 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31851 31851 else
31852 31852 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31853 31853 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31854 31854 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31855 31855 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31856 31856 fi
31857 31857 fi
31858 31858 fi
31859 31859
31860 31860 fi
31861 31861 # Work around the insanely named ProgramFiles(x86) env variable
31862 31862 PROGRAMFILES_X86="`env | $SED -n 's/^ProgramFiles(x86)=//p'`"
31863 31863 if test "x$PROGRAMFILES_X86" != x; then
31864 31864
31865 31865 if test "x$VS_ENV_CMD" = x; then
31866 31866 VS_VERSION="${VS_VERSION}"
31867 31867 VS_BASE="$PROGRAMFILES_X86/$VS_INSTALL_DIR"
31868 31868 METHOD="well-known name"
31869 31869
31870 31870 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31871 31871 VCVARSFILE="vc/bin/vcvars32.bat"
31872 31872 else
31873 31873 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31874 31874 fi
31875 31875
31876 31876
31877 31877 windows_path="$VS_BASE"
31878 31878 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31879 31879 unix_path=`$CYGPATH -u "$windows_path"`
31880 31880 VS_BASE="$unix_path"
31881 31881 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31882 31882 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31883 31883 VS_BASE="$unix_path"
31884 31884 fi
31885 31885
31886 31886 if test -d "$VS_BASE"; then
31887 31887 if test -f "$VS_BASE/$VCVARSFILE"; then
31888 31888 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31889 31889 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31890 31890 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31891 31891 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31892 31892 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31893 31893 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31894 31894 else
31895 31895 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31896 31896 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31897 31897 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31898 31898 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31899 31899 fi
31900 31900 fi
31901 31901 fi
31902 31902
31903 31903 fi
31904 31904
31905 31905 if test "x$VS_ENV_CMD" = x; then
31906 31906 VS_VERSION="${VS_VERSION}"
31907 31907 VS_BASE="C:/Program Files/$VS_INSTALL_DIR"
31908 31908 METHOD="well-known name"
31909 31909
31910 31910 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31911 31911 VCVARSFILE="vc/bin/vcvars32.bat"
31912 31912 else
31913 31913 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31914 31914 fi
31915 31915
31916 31916
31917 31917 windows_path="$VS_BASE"
31918 31918 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31919 31919 unix_path=`$CYGPATH -u "$windows_path"`
31920 31920 VS_BASE="$unix_path"
31921 31921 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31922 31922 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31923 31923 VS_BASE="$unix_path"
31924 31924 fi
31925 31925
31926 31926 if test -d "$VS_BASE"; then
31927 31927 if test -f "$VS_BASE/$VCVARSFILE"; then
31928 31928 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31929 31929 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31930 31930 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31931 31931 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31932 31932 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31933 31933 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31934 31934 else
31935 31935 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31936 31936 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31937 31937 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31938 31938 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31939 31939 fi
31940 31940 fi
31941 31941 fi
31942 31942
31943 31943
31944 31944 if test "x$VS_ENV_CMD" = x; then
31945 31945 VS_VERSION="${VS_VERSION}"
31946 31946 VS_BASE="C:/Program Files (x86)/$VS_INSTALL_DIR"
31947 31947 METHOD="well-known name"
31948 31948
31949 31949 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
31950 31950 VCVARSFILE="vc/bin/vcvars32.bat"
31951 31951 else
31952 31952 VCVARSFILE="vc/bin/amd64/vcvars64.bat"
31953 31953 fi
31954 31954
31955 31955
31956 31956 windows_path="$VS_BASE"
31957 31957 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31958 31958 unix_path=`$CYGPATH -u "$windows_path"`
31959 31959 VS_BASE="$unix_path"
31960 31960 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31961 31961 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31962 31962 VS_BASE="$unix_path"
31963 31963 fi
31964 31964
31965 31965 if test -d "$VS_BASE"; then
31966 31966 if test -f "$VS_BASE/$VCVARSFILE"; then
31967 31967 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31968 31968 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31969 31969 VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
31970 31970 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
31971 31971 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
31972 31972 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
31973 31973 else
31974 31974 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
31975 31975 $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
31976 31976 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
31977 31977 $as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
31978 31978 fi
31979 31979 fi
31980 31980 fi
31981 31981
31982 31982
31983 31983 if test "x$SDK_INSTALL_DIR" != x; then
31984 31984 if test "x$ProgramW6432" != x; then
31985 31985
31986 31986 if test "x$VS_ENV_CMD" = x; then
31987 31987 VS_VERSION="${VS_VERSION}"
31988 31988 WIN_SDK_BASE="$ProgramW6432/$SDK_INSTALL_DIR"
31989 31989 METHOD="well-known name"
31990 31990
31991 31991 windows_path="$WIN_SDK_BASE"
31992 31992 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31993 31993 unix_path=`$CYGPATH -u "$windows_path"`
31994 31994 WIN_SDK_BASE="$unix_path"
31995 31995 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31996 31996 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31997 31997 WIN_SDK_BASE="$unix_path"
31998 31998 fi
31999 31999
32000 32000 if test -d "$WIN_SDK_BASE"; then
32001 32001 # There have been cases of partial or broken SDK installations. A missing
32002 32002 # lib dir is not going to work.
32003 32003 if test ! -d "$WIN_SDK_BASE/lib"; then
32004 32004 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32005 32005 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32006 32006 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
32007 32007 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
32008 32008 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
32009 32009 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32010 32010 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32011 32011 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
32012 32012 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
32013 32013 VS_ENV_ARGS="/x86"
32014 32014 else
32015 32015 VS_ENV_ARGS="/x64"
32016 32016 fi
32017 32017 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
32018 32018 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
32019 32019 # TODO: improve detection for other versions of SDK
32020 32020 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
32021 32021 else
32022 32022 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32023 32023 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32024 32024 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
32025 32025 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
32026 32026 fi
32027 32027 fi
32028 32028 fi
32029 32029
32030 32030 fi
32031 32031 if test "x$PROGRAMW6432" != x; then
32032 32032
32033 32033 if test "x$VS_ENV_CMD" = x; then
32034 32034 VS_VERSION="${VS_VERSION}"
32035 32035 WIN_SDK_BASE="$PROGRAMW6432/$SDK_INSTALL_DIR"
32036 32036 METHOD="well-known name"
32037 32037
32038 32038 windows_path="$WIN_SDK_BASE"
32039 32039 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32040 32040 unix_path=`$CYGPATH -u "$windows_path"`
32041 32041 WIN_SDK_BASE="$unix_path"
32042 32042 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32043 32043 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32044 32044 WIN_SDK_BASE="$unix_path"
32045 32045 fi
32046 32046
32047 32047 if test -d "$WIN_SDK_BASE"; then
32048 32048 # There have been cases of partial or broken SDK installations. A missing
32049 32049 # lib dir is not going to work.
32050 32050 if test ! -d "$WIN_SDK_BASE/lib"; then
32051 32051 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32052 32052 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32053 32053 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
32054 32054 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
32055 32055 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
32056 32056 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32057 32057 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32058 32058 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
32059 32059 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
32060 32060 VS_ENV_ARGS="/x86"
32061 32061 else
32062 32062 VS_ENV_ARGS="/x64"
32063 32063 fi
32064 32064 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
32065 32065 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
32066 32066 # TODO: improve detection for other versions of SDK
32067 32067 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
32068 32068 else
32069 32069 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32070 32070 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32071 32071 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
32072 32072 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
32073 32073 fi
32074 32074 fi
32075 32075 fi
32076 32076
32077 32077 fi
32078 32078 if test "x$PROGRAMFILES" != x; then
32079 32079
32080 32080 if test "x$VS_ENV_CMD" = x; then
32081 32081 VS_VERSION="${VS_VERSION}"
32082 32082 WIN_SDK_BASE="$PROGRAMFILES/$SDK_INSTALL_DIR"
32083 32083 METHOD="well-known name"
32084 32084
32085 32085 windows_path="$WIN_SDK_BASE"
32086 32086 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32087 32087 unix_path=`$CYGPATH -u "$windows_path"`
32088 32088 WIN_SDK_BASE="$unix_path"
32089 32089 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32090 32090 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32091 32091 WIN_SDK_BASE="$unix_path"
32092 32092 fi
32093 32093
32094 32094 if test -d "$WIN_SDK_BASE"; then
32095 32095 # There have been cases of partial or broken SDK installations. A missing
32096 32096 # lib dir is not going to work.
32097 32097 if test ! -d "$WIN_SDK_BASE/lib"; then
32098 32098 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32099 32099 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32100 32100 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
32101 32101 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
32102 32102 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
32103 32103 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32104 32104 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32105 32105 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
32106 32106 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
32107 32107 VS_ENV_ARGS="/x86"
32108 32108 else
32109 32109 VS_ENV_ARGS="/x64"
32110 32110 fi
32111 32111 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
32112 32112 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
32113 32113 # TODO: improve detection for other versions of SDK
32114 32114 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
32115 32115 else
32116 32116 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32117 32117 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32118 32118 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
32119 32119 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
32120 32120 fi
32121 32121 fi
32122 32122 fi
32123 32123
32124 32124 fi
32125 32125
32126 32126 if test "x$VS_ENV_CMD" = x; then
32127 32127 VS_VERSION="${VS_VERSION}"
32128 32128 WIN_SDK_BASE="C:/Program Files/$SDK_INSTALL_DIR"
32129 32129 METHOD="well-known name"
32130 32130
32131 32131 windows_path="$WIN_SDK_BASE"
32132 32132 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32133 32133 unix_path=`$CYGPATH -u "$windows_path"`
32134 32134 WIN_SDK_BASE="$unix_path"
32135 32135 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32136 32136 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32137 32137 WIN_SDK_BASE="$unix_path"
32138 32138 fi
32139 32139
32140 32140 if test -d "$WIN_SDK_BASE"; then
32141 32141 # There have been cases of partial or broken SDK installations. A missing
32142 32142 # lib dir is not going to work.
32143 32143 if test ! -d "$WIN_SDK_BASE/lib"; then
32144 32144 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32145 32145 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32146 32146 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
32147 32147 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
32148 32148 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
32149 32149 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32150 32150 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32151 32151 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
32152 32152 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
32153 32153 VS_ENV_ARGS="/x86"
32154 32154 else
32155 32155 VS_ENV_ARGS="/x64"
32156 32156 fi
32157 32157 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
32158 32158 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
32159 32159 # TODO: improve detection for other versions of SDK
32160 32160 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
32161 32161 else
32162 32162 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32163 32163 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32164 32164 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
32165 32165 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
32166 32166 fi
32167 32167 fi
32168 32168 fi
32169 32169
32170 32170
32171 32171 if test "x$VS_ENV_CMD" = x; then
32172 32172 VS_VERSION="${VS_VERSION}"
32173 32173 WIN_SDK_BASE="C:/Program Files (x86)/$SDK_INSTALL_DIR"
32174 32174 METHOD="well-known name"
32175 32175
32176 32176 windows_path="$WIN_SDK_BASE"
32177 32177 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32178 32178 unix_path=`$CYGPATH -u "$windows_path"`
32179 32179 WIN_SDK_BASE="$unix_path"
32180 32180 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32181 32181 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32182 32182 WIN_SDK_BASE="$unix_path"
32183 32183 fi
32184 32184
32185 32185 if test -d "$WIN_SDK_BASE"; then
32186 32186 # There have been cases of partial or broken SDK installations. A missing
32187 32187 # lib dir is not going to work.
32188 32188 if test ! -d "$WIN_SDK_BASE/lib"; then
32189 32189 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32190 32190 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32191 32191 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
32192 32192 $as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
32193 32193 elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
32194 32194 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32195 32195 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32196 32196 VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
32197 32197 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
32198 32198 VS_ENV_ARGS="/x86"
32199 32199 else
32200 32200 VS_ENV_ARGS="/x64"
32201 32201 fi
32202 32202 # PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
32203 32203 # 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
32204 32204 # TODO: improve detection for other versions of SDK
32205 32205 eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
32206 32206 else
32207 32207 { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
32208 32208 $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
32209 32209 { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
32210 32210 $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
32211 32211 fi
32212 32212 fi
32213 32213 fi
32214 32214
32215 32215 fi
32216 32216
32217 32217 if test "x$VS_ENV_CMD" != x; then
32218 32218 TOOLCHAIN_VERSION=$VS_VERSION
32219 32219 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
32220 32220 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
32221 32221 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
32222 32222 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
32223 32223 # The rest of the variables are already evaled while probing
32224 32224 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
32225 32225 $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
32226 32226 break
32227 32227 fi
32228 32228 done
32229 32229
32230 32230
32231 32231 # If we have a devkit, skip all of the below.
32232 32232 if test "x$DEVKIT_VS_VERSION" = x; then
32233 32233 if test "x$VS_ENV_CMD" != x; then
32234 32234 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
32235 32235
32236 32236 # Only process if variable expands to non-empty
32237 32237
32238 32238 if test "x$VS_ENV_CMD" != x; then
32239 32239 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32240 32240
32241 32241 # First separate the path from the arguments. This will split at the first
32242 32242 # space.
32243 32243 complete="$VS_ENV_CMD"
32244 32244 path="${complete%% *}"
32245 32245 tmp="$complete EOL"
32246 32246 arguments="${tmp#* }"
32247 32247
32248 32248 # Input might be given as Windows format, start by converting to
32249 32249 # unix format.
32250 32250 new_path=`$CYGPATH -u "$path"`
32251 32251
32252 32252 # Now try to locate executable using which
32253 32253 new_path=`$WHICH "$new_path" 2> /dev/null`
32254 32254 # bat and cmd files are not always considered executable in cygwin causing which
32255 32255 # to not find them
32256 32256 if test "x$new_path" = x \
32257 32257 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
32258 32258 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
32259 32259 new_path=`$CYGPATH -u "$path"`
32260 32260 fi
32261 32261 if test "x$new_path" = x; then
32262 32262 # Oops. Which didn't find the executable.
32263 32263 # The splitting of arguments from the executable at a space might have been incorrect,
32264 32264 # since paths with space are more likely in Windows. Give it another try with the whole
32265 32265 # argument.
32266 32266 path="$complete"
32267 32267 arguments="EOL"
32268 32268 new_path=`$CYGPATH -u "$path"`
32269 32269 new_path=`$WHICH "$new_path" 2> /dev/null`
32270 32270 # bat and cmd files are not always considered executable in cygwin causing which
32271 32271 # to not find them
32272 32272 if test "x$new_path" = x \
32273 32273 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
32274 32274 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
32275 32275 new_path=`$CYGPATH -u "$path"`
32276 32276 fi
32277 32277 if test "x$new_path" = x; then
32278 32278 # It's still not found. Now this is an unrecoverable error.
32279 32279 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
32280 32280 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
32281 32281 has_space=`$ECHO "$complete" | $GREP " "`
32282 32282 if test "x$has_space" != x; then
32283 32283 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32284 32284 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32285 32285 fi
32286 32286 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
32287 32287 fi
32288 32288 fi
32289 32289
32290 32290 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
32291 32291 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
32292 32292 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
32293 32293 # "foo.exe" is OK but "foo" is an error.
32294 32294 #
32295 32295 # This test is therefore slightly more accurate than "test -f" to check for file presence.
32296 32296 # It is also a way to make sure we got the proper file name for the real test later on.
32297 32297 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
32298 32298 if test "x$test_shortpath" = x; then
32299 32299 # Short path failed, file does not exist as specified.
32300 32300 # Try adding .exe or .cmd
32301 32301 if test -f "${new_path}.exe"; then
32302 32302 input_to_shortpath="${new_path}.exe"
32303 32303 elif test -f "${new_path}.cmd"; then
32304 32304 input_to_shortpath="${new_path}.cmd"
32305 32305 else
32306 32306 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
32307 32307 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
32308 32308 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
32309 32309 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
32310 32310 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
32311 32311 fi
32312 32312 else
32313 32313 input_to_shortpath="$new_path"
32314 32314 fi
32315 32315
32316 32316 # Call helper function which possibly converts this using DOS-style short mode.
32317 32317 # If so, the updated path is stored in $new_path.
32318 32318 new_path="$input_to_shortpath"
32319 32319
32320 32320 input_path="$input_to_shortpath"
32321 32321 # Check if we need to convert this using DOS-style short mode. If the path
32322 32322 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32323 32323 # take no chances and rewrite it.
32324 32324 # Note: m4 eats our [], so we need to use [ and ] instead.
32325 32325 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32326 32326 if test "x$has_forbidden_chars" != x; then
32327 32327 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32328 32328 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32329 32329 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32330 32330 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32331 32331 # Going to short mode and back again did indeed matter. Since short mode is
32332 32332 # case insensitive, let's make it lowercase to improve readability.
32333 32333 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32334 32334 # Now convert it back to Unix-style (cygpath)
32335 32335 input_path=`$CYGPATH -u "$shortmode_path"`
32336 32336 new_path="$input_path"
32337 32337 fi
32338 32338 fi
32339 32339
32340 32340 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32341 32341 if test "x$test_cygdrive_prefix" = x; then
32342 32342 # As a simple fix, exclude /usr/bin since it's not a real path.
32343 32343 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
32344 32344 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32345 32345 # a path prefixed by /cygdrive for fixpath to work.
32346 32346 new_path="$CYGWIN_ROOT_PATH$input_path"
32347 32347 fi
32348 32348 fi
32349 32349
32350 32350 # remove trailing .exe if any
32351 32351 new_path="${new_path/%.exe/}"
32352 32352
32353 32353 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32354 32354
32355 32355 # First separate the path from the arguments. This will split at the first
32356 32356 # space.
32357 32357 complete="$VS_ENV_CMD"
32358 32358 path="${complete%% *}"
32359 32359 tmp="$complete EOL"
32360 32360 arguments="${tmp#* }"
32361 32361
32362 32362 # Input might be given as Windows format, start by converting to
32363 32363 # unix format.
32364 32364 new_path="$path"
32365 32365
32366 32366 windows_path="$new_path"
32367 32367 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32368 32368 unix_path=`$CYGPATH -u "$windows_path"`
32369 32369 new_path="$unix_path"
32370 32370 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32371 32371 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32372 32372 new_path="$unix_path"
32373 32373 fi
32374 32374
32375 32375
32376 32376 # Now try to locate executable using which
32377 32377 new_path=`$WHICH "$new_path" 2> /dev/null`
32378 32378
32379 32379 if test "x$new_path" = x; then
32380 32380 # Oops. Which didn't find the executable.
32381 32381 # The splitting of arguments from the executable at a space might have been incorrect,
32382 32382 # since paths with space are more likely in Windows. Give it another try with the whole
32383 32383 # argument.
32384 32384 path="$complete"
32385 32385 arguments="EOL"
32386 32386 new_path="$path"
32387 32387
32388 32388 windows_path="$new_path"
32389 32389 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32390 32390 unix_path=`$CYGPATH -u "$windows_path"`
32391 32391 new_path="$unix_path"
32392 32392 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32393 32393 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32394 32394 new_path="$unix_path"
32395 32395 fi
32396 32396
32397 32397
32398 32398 new_path=`$WHICH "$new_path" 2> /dev/null`
32399 32399 # bat and cmd files are not always considered executable in MSYS causing which
32400 32400 # to not find them
32401 32401 if test "x$new_path" = x \
32402 32402 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
32403 32403 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
32404 32404 new_path="$path"
32405 32405
32406 32406 windows_path="$new_path"
32407 32407 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32408 32408 unix_path=`$CYGPATH -u "$windows_path"`
32409 32409 new_path="$unix_path"
32410 32410 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32411 32411 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32412 32412 new_path="$unix_path"
32413 32413 fi
32414 32414
32415 32415 fi
32416 32416
32417 32417 if test "x$new_path" = x; then
32418 32418 # It's still not found. Now this is an unrecoverable error.
32419 32419 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
32420 32420 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
32421 32421 has_space=`$ECHO "$complete" | $GREP " "`
32422 32422 if test "x$has_space" != x; then
32423 32423 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
32424 32424 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
32425 32425 fi
32426 32426 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
32427 32427 fi
32428 32428 fi
32429 32429
32430 32430 # Now new_path has a complete unix path to the binary
32431 32431 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
32432 32432 # Keep paths in /bin as-is, but remove trailing .exe if any
32433 32433 new_path="${new_path/%.exe/}"
32434 32434 # Do not save /bin paths to all_fixpath_prefixes!
32435 32435 else
32436 32436 # Not in mixed or Windows style, start by that.
32437 32437 new_path=`cmd //c echo $new_path`
32438 32438
32439 32439 input_path="$new_path"
32440 32440 # Check if we need to convert this using DOS-style short mode. If the path
32441 32441 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32442 32442 # take no chances and rewrite it.
32443 32443 # Note: m4 eats our [], so we need to use [ and ] instead.
32444 32444 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
32445 32445 if test "x$has_forbidden_chars" != x; then
32446 32446 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32447 32447 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32448 32448 fi
32449 32449
32450 32450 # Output is in $new_path
32451 32451
32452 32452 windows_path="$new_path"
32453 32453 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32454 32454 unix_path=`$CYGPATH -u "$windows_path"`
32455 32455 new_path="$unix_path"
32456 32456 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32457 32457 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32458 32458 new_path="$unix_path"
32459 32459 fi
32460 32460
32461 32461 # remove trailing .exe if any
32462 32462 new_path="${new_path/%.exe/}"
32463 32463
32464 32464 # Save the first 10 bytes of this path to the storage, so fixpath can work.
32465 32465 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
32466 32466 fi
32467 32467
32468 32468 else
32469 32469 # We're on a unix platform. Hooray! :)
32470 32470 # First separate the path from the arguments. This will split at the first
32471 32471 # space.
32472 32472 complete="$VS_ENV_CMD"
32473 32473 path="${complete%% *}"
32474 32474 tmp="$complete EOL"
32475 32475 arguments="${tmp#* }"
32476 32476
32477 32477 # Cannot rely on the command "which" here since it doesn't always work.
32478 32478 is_absolute_path=`$ECHO "$path" | $GREP ^/`
32479 32479 if test -z "$is_absolute_path"; then
32480 32480 # Path to executable is not absolute. Find it.
32481 32481 IFS_save="$IFS"
32482 32482 IFS=:
32483 32483 for p in $PATH; do
32484 32484 if test -f "$p/$path" && test -x "$p/$path"; then
32485 32485 new_path="$p/$path"
32486 32486 break
32487 32487 fi
32488 32488 done
32489 32489 IFS="$IFS_save"
32490 32490 else
32491 32491 # This is an absolute path, we can use it without further modifications.
32492 32492 new_path="$path"
32493 32493 fi
32494 32494
32495 32495 if test "x$new_path" = x; then
32496 32496 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
32497 32497 $as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
32498 32498 has_space=`$ECHO "$complete" | $GREP " "`
32499 32499 if test "x$has_space" != x; then
32500 32500 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
32501 32501 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
32502 32502 fi
32503 32503 as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
32504 32504 fi
32505 32505 fi
32506 32506
32507 32507 # Now join together the path and the arguments once again
32508 32508 if test "x$arguments" != xEOL; then
32509 32509 new_complete="$new_path ${arguments% *}"
32510 32510 else
32511 32511 new_complete="$new_path"
32512 32512 fi
32513 32513
32514 32514 if test "x$complete" != "x$new_complete"; then
32515 32515 VS_ENV_CMD="$new_complete"
32516 32516 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
32517 32517 $as_echo "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
32518 32518 fi
32519 32519 fi
32520 32520
32521 32521
32522 32522 # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat
32523 32523 { $as_echo "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
32524 32524 $as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
32525 32525
32526 32526 # We need to create a couple of temporary files.
32527 32527 VS_ENV_TMP_DIR="$CONFIGURESUPPORT_OUTPUTDIR/vs-env"
32528 32528 $MKDIR -p $VS_ENV_TMP_DIR
32529 32529
32530 32530 # Cannot use the VS10 setup script directly (since it only updates the DOS subshell environment).
32531 32531 # Instead create a shell script which will set the relevant variables when run.
32532 32532 WINPATH_VS_ENV_CMD="$VS_ENV_CMD"
32533 32533
32534 32534 unix_path="$WINPATH_VS_ENV_CMD"
32535 32535 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32536 32536 windows_path=`$CYGPATH -m "$unix_path"`
32537 32537 WINPATH_VS_ENV_CMD="$windows_path"
32538 32538 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32539 32539 windows_path=`cmd //c echo $unix_path`
32540 32540 WINPATH_VS_ENV_CMD="$windows_path"
32541 32541 fi
32542 32542
32543 32543 WINPATH_BASH="$BASH"
32544 32544
32545 32545 unix_path="$WINPATH_BASH"
32546 32546 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32547 32547 windows_path=`$CYGPATH -m "$unix_path"`
32548 32548 WINPATH_BASH="$windows_path"
32549 32549 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32550 32550 windows_path=`cmd //c echo $unix_path`
32551 32551 WINPATH_BASH="$windows_path"
32552 32552 fi
32553 32553
32554 32554
32555 32555 # Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell
32556 32556 # script (executable by bash) that will setup the important variables.
32557 32557 EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat"
32558 32558 $ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE
32559 32559 # This will end up something like:
32560 32560 # call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat
32561 32561 $ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE
32562 32562 # These will end up something like:
32563 32563 # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh
32564 32564 # The trailing space for everyone except PATH is no typo, but is needed due
32565 32565 # to trailing \ in the Windows paths. These will be stripped later.
32566 32566 $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' \
32567 32567 >> $EXTRACT_VC_ENV_BAT_FILE
32568 32568 $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' \
32569 32569 >> $EXTRACT_VC_ENV_BAT_FILE
32570 32570 $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' \
32571 32571 >> $EXTRACT_VC_ENV_BAT_FILE
32572 32572 $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \
32573 32573 >> $EXTRACT_VC_ENV_BAT_FILE
32574 32574 $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \
32575 32575 >> $EXTRACT_VC_ENV_BAT_FILE
32576 32576 $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \
32577 32577 >> $EXTRACT_VC_ENV_BAT_FILE
32578 32578
32579 32579 # Now execute the newly created bat file.
32580 32580 # The | cat is to stop SetEnv.Cmd to mess with system colors on msys.
32581 32581 # Change directory so we don't need to mess with Windows paths in redirects.
32582 32582 cd $VS_ENV_TMP_DIR
32583 32583 cmd /c extract-vs-env.bat | $CAT
32584 32584 cd $CURDIR
32585 32585
32586 32586 if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
32587 32587 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
32588 32588 $as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
32589 32589 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
32590 32590 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
32591 32591 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
32592 32592 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
32593 32593 as_fn_error $? "Cannot continue" "$LINENO" 5
32594 32594 fi
32595 32595
32596 32596 # Now set all paths and other env variables. This will allow the rest of
32597 32597 # the configure script to find and run the compiler in the proper way.
32598 32598 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
32599 32599 $as_echo "$as_me: Setting extracted environment variables" >&6;}
32600 32600 . $VS_ENV_TMP_DIR/set-vs-env.sh
32601 32601 # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
32602 32602 # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
32603 32603 else
32604 32604 # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
32605 32605 { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
32606 32606 $as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
32607 32607 fi
32608 32608 fi
32609 32609
32610 32610 # At this point, we should have correct variables in the environment, or we can't continue.
32611 32611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
32612 32612 $as_echo_n "checking for Visual Studio variables... " >&6; }
32613 32613
32614 32614 if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
32615 32615 || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
32616 32616 if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
32617 32617 { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
32618 32618 $as_echo "present but broken" >&6; }
32619 32619 as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
32620 32620 else
32621 32621 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
32622 32622 $as_echo "ok" >&6; }
32623 32623 # Remove any trailing "\" ";" and " " from the variables.
32624 32624 VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED -e 's/\\\\*;* *$//'`
32625 32625 VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\*;* *$//'`
32626 32626 VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'`
32627 32627 WindowsSDKDir=`$ECHO "$WindowsSDKDir" | $SED 's/\\\\* *$//'`
32628 32628 WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'`
32629 32629 # Remove any paths containing # (typically F#) as that messes up make. This
32630 32630 # is needed if visual studio was installed with F# support.
32631 32631 VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[^:#]*#[^:]*://g'`
32632 32632
32633 32633
32634 32634
32635 32635
32636 32636
32637 32637 # Convert VS_INCLUDE into SYSROOT_CFLAGS
32638 32638 OLDIFS="$IFS"
32639 32639 IFS=";"
32640 32640 for i in $VS_INCLUDE; do
32641 32641 ipath=$i
32642 32642 # Only process non-empty elements
32643 32643 if test "x$ipath" != x; then
32644 32644 IFS="$OLDIFS"
32645 32645 # Check that directory exists before calling fixup_path
32646 32646 testpath=$ipath
32647 32647
32648 32648 windows_path="$testpath"
32649 32649 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32650 32650 unix_path=`$CYGPATH -u "$windows_path"`
32651 32651 testpath="$unix_path"
32652 32652 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32653 32653 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32654 32654 testpath="$unix_path"
32655 32655 fi
32656 32656
32657 32657 if test -d "$testpath"; then
32658 32658
32659 32659 # Only process if variable expands to non-empty
32660 32660
32661 32661 if test "x$ipath" != x; then
32662 32662 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32663 32663
32664 32664 # Input might be given as Windows format, start by converting to
32665 32665 # unix format.
32666 32666 path="$ipath"
32667 32667 new_path=`$CYGPATH -u "$path"`
32668 32668
32669 32669 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
32670 32670 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
32671 32671 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
32672 32672 # "foo.exe" is OK but "foo" is an error.
32673 32673 #
32674 32674 # This test is therefore slightly more accurate than "test -f" to check for file precense.
32675 32675 # It is also a way to make sure we got the proper file name for the real test later on.
32676 32676 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
32677 32677 if test "x$test_shortpath" = x; then
32678 32678 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of ipath, which resolves as \"$path\", is invalid." >&5
32679 32679 $as_echo "$as_me: The path of ipath, which resolves as \"$path\", is invalid." >&6;}
32680 32680 as_fn_error $? "Cannot locate the the path of ipath" "$LINENO" 5
32681 32681 fi
32682 32682
32683 32683 # Call helper function which possibly converts this using DOS-style short mode.
32684 32684 # If so, the updated path is stored in $new_path.
32685 32685
32686 32686 input_path="$new_path"
32687 32687 # Check if we need to convert this using DOS-style short mode. If the path
32688 32688 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32689 32689 # take no chances and rewrite it.
32690 32690 # Note: m4 eats our [], so we need to use [ and ] instead.
32691 32691 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32692 32692 if test "x$has_forbidden_chars" != x; then
32693 32693 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32694 32694 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32695 32695 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32696 32696 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32697 32697 # Going to short mode and back again did indeed matter. Since short mode is
32698 32698 # case insensitive, let's make it lowercase to improve readability.
32699 32699 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32700 32700 # Now convert it back to Unix-style (cygpath)
32701 32701 input_path=`$CYGPATH -u "$shortmode_path"`
32702 32702 new_path="$input_path"
32703 32703 fi
32704 32704 fi
32705 32705
32706 32706 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32707 32707 if test "x$test_cygdrive_prefix" = x; then
32708 32708 # As a simple fix, exclude /usr/bin since it's not a real path.
32709 32709 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
32710 32710 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32711 32711 # a path prefixed by /cygdrive for fixpath to work.
32712 32712 new_path="$CYGWIN_ROOT_PATH$input_path"
32713 32713 fi
32714 32714 fi
32715 32715
32716 32716
32717 32717 if test "x$path" != "x$new_path"; then
32718 32718 ipath="$new_path"
32719 32719 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ipath to \"$new_path\"" >&5
32720 32720 $as_echo "$as_me: Rewriting ipath to \"$new_path\"" >&6;}
32721 32721 fi
32722 32722
32723 32723 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32724 32724
32725 32725 path="$ipath"
32726 32726 has_colon=`$ECHO $path | $GREP ^.:`
32727 32727 new_path="$path"
32728 32728 if test "x$has_colon" = x; then
32729 32729 # Not in mixed or Windows style, start by that.
32730 32730 new_path=`cmd //c echo $path`
32731 32731 fi
32732 32732
32733 32733
32734 32734 input_path="$new_path"
32735 32735 # Check if we need to convert this using DOS-style short mode. If the path
32736 32736 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32737 32737 # take no chances and rewrite it.
32738 32738 # Note: m4 eats our [], so we need to use [ and ] instead.
32739 32739 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
32740 32740 if test "x$has_forbidden_chars" != x; then
32741 32741 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32742 32742 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32743 32743 fi
32744 32744
32745 32745
32746 32746 windows_path="$new_path"
32747 32747 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32748 32748 unix_path=`$CYGPATH -u "$windows_path"`
32749 32749 new_path="$unix_path"
32750 32750 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32751 32751 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32752 32752 new_path="$unix_path"
32753 32753 fi
32754 32754
32755 32755 if test "x$path" != "x$new_path"; then
32756 32756 ipath="$new_path"
32757 32757 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ipath to \"$new_path\"" >&5
32758 32758 $as_echo "$as_me: Rewriting ipath to \"$new_path\"" >&6;}
32759 32759 fi
32760 32760
32761 32761 # Save the first 10 bytes of this path to the storage, so fixpath can work.
32762 32762 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
32763 32763
32764 32764 else
32765 32765 # We're on a unix platform. Hooray! :)
32766 32766 path="$ipath"
32767 32767 has_space=`$ECHO "$path" | $GREP " "`
32768 32768 if test "x$has_space" != x; then
32769 32769 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of ipath, which resolves as \"$path\", is invalid." >&5
32770 32770 $as_echo "$as_me: The path of ipath, which resolves as \"$path\", is invalid." >&6;}
32771 32771 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
32772 32772 fi
32773 32773
32774 32774 # Use eval to expand a potential ~
32775 32775 eval path="$path"
32776 32776 if test ! -f "$path" && test ! -d "$path"; then
32777 32777 as_fn_error $? "The path of ipath, which resolves as \"$path\", is not found." "$LINENO" 5
32778 32778 fi
32779 32779
32780 32780 if test -d "$path"; then
32781 32781 ipath="`cd "$path"; $THEPWDCMD -L`"
32782 32782 else
32783 32783 dir="`$DIRNAME "$path"`"
32784 32784 base="`$BASENAME "$path"`"
32785 32785 ipath="`cd "$dir"; $THEPWDCMD -L`/$base"
32786 32786 fi
32787 32787 fi
32788 32788 fi
32789 32789
32790 32790 SYSROOT_CFLAGS="$SYSROOT_CFLAGS -I$ipath"
32791 32791 fi
32792 32792 IFS=";"
32793 32793 fi
32794 32794 done
32795 32795 # Convert VS_LIB into SYSROOT_LDFLAGS
32796 32796 for i in $VS_LIB; do
32797 32797 libpath=$i
32798 32798 # Only process non-empty elements
32799 32799 if test "x$libpath" != x; then
32800 32800 IFS="$OLDIFS"
32801 32801 # Check that directory exists before calling fixup_path
32802 32802 testpath=$libpath
32803 32803
32804 32804 windows_path="$testpath"
32805 32805 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32806 32806 unix_path=`$CYGPATH -u "$windows_path"`
32807 32807 testpath="$unix_path"
32808 32808 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32809 32809 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32810 32810 testpath="$unix_path"
32811 32811 fi
32812 32812
32813 32813 if test -d "$testpath"; then
32814 32814
32815 32815 # Only process if variable expands to non-empty
32816 32816
32817 32817 if test "x$libpath" != x; then
32818 32818 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32819 32819
32820 32820 # Input might be given as Windows format, start by converting to
32821 32821 # unix format.
32822 32822 path="$libpath"
32823 32823 new_path=`$CYGPATH -u "$path"`
32824 32824
32825 32825 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
32826 32826 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
32827 32827 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
32828 32828 # "foo.exe" is OK but "foo" is an error.
32829 32829 #
32830 32830 # This test is therefore slightly more accurate than "test -f" to check for file precense.
32831 32831 # It is also a way to make sure we got the proper file name for the real test later on.
32832 32832 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
32833 32833 if test "x$test_shortpath" = x; then
32834 32834 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of libpath, which resolves as \"$path\", is invalid." >&5
32835 32835 $as_echo "$as_me: The path of libpath, which resolves as \"$path\", is invalid." >&6;}
32836 32836 as_fn_error $? "Cannot locate the the path of libpath" "$LINENO" 5
32837 32837 fi
32838 32838
32839 32839 # Call helper function which possibly converts this using DOS-style short mode.
32840 32840 # If so, the updated path is stored in $new_path.
32841 32841
32842 32842 input_path="$new_path"
32843 32843 # Check if we need to convert this using DOS-style short mode. If the path
32844 32844 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32845 32845 # take no chances and rewrite it.
32846 32846 # Note: m4 eats our [], so we need to use [ and ] instead.
32847 32847 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32848 32848 if test "x$has_forbidden_chars" != x; then
32849 32849 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32850 32850 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32851 32851 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32852 32852 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32853 32853 # Going to short mode and back again did indeed matter. Since short mode is
32854 32854 # case insensitive, let's make it lowercase to improve readability.
32855 32855 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32856 32856 # Now convert it back to Unix-style (cygpath)
32857 32857 input_path=`$CYGPATH -u "$shortmode_path"`
32858 32858 new_path="$input_path"
32859 32859 fi
32860 32860 fi
32861 32861
32862 32862 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32863 32863 if test "x$test_cygdrive_prefix" = x; then
32864 32864 # As a simple fix, exclude /usr/bin since it's not a real path.
32865 32865 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
32866 32866 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32867 32867 # a path prefixed by /cygdrive for fixpath to work.
32868 32868 new_path="$CYGWIN_ROOT_PATH$input_path"
32869 32869 fi
32870 32870 fi
32871 32871
32872 32872
32873 32873 if test "x$path" != "x$new_path"; then
32874 32874 libpath="$new_path"
32875 32875 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting libpath to \"$new_path\"" >&5
32876 32876 $as_echo "$as_me: Rewriting libpath to \"$new_path\"" >&6;}
32877 32877 fi
32878 32878
32879 32879 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32880 32880
32881 32881 path="$libpath"
32882 32882 has_colon=`$ECHO $path | $GREP ^.:`
32883 32883 new_path="$path"
32884 32884 if test "x$has_colon" = x; then
32885 32885 # Not in mixed or Windows style, start by that.
32886 32886 new_path=`cmd //c echo $path`
32887 32887 fi
32888 32888
32889 32889
32890 32890 input_path="$new_path"
32891 32891 # Check if we need to convert this using DOS-style short mode. If the path
32892 32892 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32893 32893 # take no chances and rewrite it.
32894 32894 # Note: m4 eats our [], so we need to use [ and ] instead.
32895 32895 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
32896 32896 if test "x$has_forbidden_chars" != x; then
32897 32897 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32898 32898 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32899 32899 fi
32900 32900
32901 32901
32902 32902 windows_path="$new_path"
32903 32903 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32904 32904 unix_path=`$CYGPATH -u "$windows_path"`
32905 32905 new_path="$unix_path"
32906 32906 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32907 32907 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32908 32908 new_path="$unix_path"
32909 32909 fi
32910 32910
32911 32911 if test "x$path" != "x$new_path"; then
32912 32912 libpath="$new_path"
32913 32913 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting libpath to \"$new_path\"" >&5
32914 32914 $as_echo "$as_me: Rewriting libpath to \"$new_path\"" >&6;}
32915 32915 fi
32916 32916
32917 32917 # Save the first 10 bytes of this path to the storage, so fixpath can work.
32918 32918 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
32919 32919
32920 32920 else
32921 32921 # We're on a unix platform. Hooray! :)
32922 32922 path="$libpath"
32923 32923 has_space=`$ECHO "$path" | $GREP " "`
32924 32924 if test "x$has_space" != x; then
32925 32925 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of libpath, which resolves as \"$path\", is invalid." >&5
32926 32926 $as_echo "$as_me: The path of libpath, which resolves as \"$path\", is invalid." >&6;}
32927 32927 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
32928 32928 fi
32929 32929
32930 32930 # Use eval to expand a potential ~
32931 32931 eval path="$path"
32932 32932 if test ! -f "$path" && test ! -d "$path"; then
32933 32933 as_fn_error $? "The path of libpath, which resolves as \"$path\", is not found." "$LINENO" 5
32934 32934 fi
32935 32935
32936 32936 if test -d "$path"; then
32937 32937 libpath="`cd "$path"; $THEPWDCMD -L`"
32938 32938 else
32939 32939 dir="`$DIRNAME "$path"`"
32940 32940 base="`$BASENAME "$path"`"
32941 32941 libpath="`cd "$dir"; $THEPWDCMD -L`/$base"
32942 32942 fi
32943 32943 fi
32944 32944 fi
32945 32945
32946 32946 SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -libpath:$libpath"
32947 32947 fi
32948 32948 IFS=";"
32949 32949 fi
32950 32950 done
32951 32951 IFS="$OLDIFS"
32952 32952 fi
32953 32953 else
32954 32954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
32955 32955 $as_echo "not found" >&6; }
32956 32956
32957 32957 if test "x$VS_ENV_CMD" = x; then
32958 32958 { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
32959 32959 $as_echo "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
32960 32960 { $as_echo "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
32961 32961 $as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
32962 32962 else
32963 32963 { $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
32964 32964 $as_echo "$as_me: Running the extraction script failed." >&6;}
32965 32965 fi
32966 32966 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
32967 32967 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
32968 32968 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
32969 32969 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
32970 32970 as_fn_error $? "Cannot continue" "$LINENO" 5
32971 32971 fi
32972 32972
32973 32973 # Reset path to VS_PATH. It will include everything that was on PATH at the time we
32974 32974 # ran TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV.
32975 32975 PATH="$VS_PATH"
32976 32976 # The microsoft toolchain also requires INCLUDE and LIB to be set.
32977 32977 export INCLUDE="$VS_INCLUDE"
32978 32978 export LIB="$VS_LIB"
32979 32979 else
32980 32980 if test "x$XCODE_VERSION_OUTPUT" != x; then
32981 32981 # For Xcode, we set the Xcode version as TOOLCHAIN_VERSION
32982 32982 TOOLCHAIN_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | $CUT -f 2 -d ' '`
32983 32983 TOOLCHAIN_DESCRIPTION="$TOOLCHAIN_DESCRIPTION from Xcode"
32984 32984 else
32985 32985 # Currently we do not define this for other toolchains. This might change as the need arise.
32986 32986 TOOLCHAIN_VERSION=
32987 32987 fi
32988 32988 fi
32989 32989
32990 32990
32991 32991 # For solaris we really need solaris tools, and not the GNU equivalent.
32992 32992 # The build tools on Solaris reside in /usr/ccs (C Compilation System),
32993 32993 # so add that to path before starting to probe.
32994 32994 # FIXME: This was originally only done for AS,NM,GNM,STRIP,OBJCOPY,OBJDUMP.
32995 32995 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
32996 32996 PATH="/usr/ccs/bin:$PATH"
32997 32997 fi
32998 32998
32999 32999 # Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
33000 33000 # override all other locations.
33001 33001 if test "x$TOOLCHAIN_PATH" != x; then
33002 33002 PATH=$TOOLCHAIN_PATH:$PATH
33003 33003 fi
33004 33004
33005 33005
33006 33006 #
33007 33007 # Setup the compilers (CC and CXX)
33008 33008 #
33009 33009
33010 33010 COMPILER_NAME=C
33011 33011 SEARCH_LIST="$TOOLCHAIN_CC_BINARY"
33012 33012
33013 33013 if test "x$CC" != x; then
33014 33014 # User has supplied compiler name already, always let that override.
33015 33015 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
33016 33016 $as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
33017 33017 if test "x`basename $CC`" = "x$CC"; then
33018 33018 # A command without a complete path is provided, search $PATH.
33019 33019
33020 33020 for ac_prog in $CC
33021 33021 do
33022 33022 # Extract the first word of "$ac_prog", so it can be a program name with args.
33023 33023 set dummy $ac_prog; ac_word=$2
33024 33024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
33025 33025 $as_echo_n "checking for $ac_word... " >&6; }
33026 33026 if ${ac_cv_path_POTENTIAL_CC+:} false; then :
33027 33027 $as_echo_n "(cached) " >&6
33028 33028 else
33029 33029 case $POTENTIAL_CC in
33030 33030 [\\/]* | ?:[\\/]*)
33031 33031 ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
33032 33032 ;;
33033 33033 *)
33034 33034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
33035 33035 for as_dir in $PATH
33036 33036 do
33037 33037 IFS=$as_save_IFS
33038 33038 test -z "$as_dir" && as_dir=.
33039 33039 for ac_exec_ext in '' $ac_executable_extensions; do
33040 33040 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
33041 33041 ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
33042 33042 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
33043 33043 break 2
33044 33044 fi
33045 33045 done
33046 33046 done
33047 33047 IFS=$as_save_IFS
33048 33048
33049 33049 ;;
33050 33050 esac
33051 33051 fi
33052 33052 POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
33053 33053 if test -n "$POTENTIAL_CC"; then
33054 33054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
33055 33055 $as_echo "$POTENTIAL_CC" >&6; }
33056 33056 else
33057 33057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33058 33058 $as_echo "no" >&6; }
33059 33059 fi
33060 33060
33061 33061
33062 33062 test -n "$POTENTIAL_CC" && break
33063 33063 done
33064 33064
33065 33065 if test "x$POTENTIAL_CC" != x; then
33066 33066 CC=$POTENTIAL_CC
33067 33067 else
33068 33068 as_fn_error $? "User supplied compiler CC=$CC could not be found" "$LINENO" 5
33069 33069 fi
33070 33070 else
33071 33071 # Otherwise it might already be a complete path
33072 33072 if test ! -x "$CC"; then
33073 33073 as_fn_error $? "User supplied compiler CC=$CC does not exist" "$LINENO" 5
33074 33074 fi
33075 33075 fi
33076 33076 else
33077 33077 # No user supplied value. Locate compiler ourselves.
33078 33078
33079 33079 # If we are cross compiling, assume cross compilation tools follows the
33080 33080 # cross compilation standard where they are prefixed with the autoconf
33081 33081 # standard name for the target. For example the binary
33082 33082 # i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
33083 33083 # If we are not cross compiling, then the default compiler name will be
33084 33084 # used.
33085 33085
33086 33086 CC=
33087 33087 # If TOOLCHAIN_PATH is set, check for all compiler names in there first
33088 33088 # before checking the rest of the PATH.
33089 33089 # FIXME: Now that we prefix the TOOLS_DIR to the PATH in the PRE_DETECTION
33090 33090 # step, this should not be necessary.
33091 33091 if test -n "$TOOLCHAIN_PATH"; then
33092 33092 PATH_save="$PATH"
33093 33093 PATH="$TOOLCHAIN_PATH"
33094 33094 for ac_prog in $SEARCH_LIST
33095 33095 do
33096 33096 # Extract the first word of "$ac_prog", so it can be a program name with args.
33097 33097 set dummy $ac_prog; ac_word=$2
33098 33098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
33099 33099 $as_echo_n "checking for $ac_word... " >&6; }
33100 33100 if ${ac_cv_path_TOOLCHAIN_PATH_CC+:} false; then :
33101 33101 $as_echo_n "(cached) " >&6
33102 33102 else
33103 33103 case $TOOLCHAIN_PATH_CC in
33104 33104 [\\/]* | ?:[\\/]*)
33105 33105 ac_cv_path_TOOLCHAIN_PATH_CC="$TOOLCHAIN_PATH_CC" # Let the user override the test with a path.
33106 33106 ;;
33107 33107 *)
33108 33108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
33109 33109 for as_dir in $PATH
33110 33110 do
33111 33111 IFS=$as_save_IFS
33112 33112 test -z "$as_dir" && as_dir=.
33113 33113 for ac_exec_ext in '' $ac_executable_extensions; do
33114 33114 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
33115 33115 ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir/$ac_word$ac_exec_ext"
33116 33116 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
33117 33117 break 2
33118 33118 fi
33119 33119 done
33120 33120 done
33121 33121 IFS=$as_save_IFS
33122 33122
33123 33123 ;;
33124 33124 esac
33125 33125 fi
33126 33126 TOOLCHAIN_PATH_CC=$ac_cv_path_TOOLCHAIN_PATH_CC
33127 33127 if test -n "$TOOLCHAIN_PATH_CC"; then
33128 33128 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
33129 33129 $as_echo "$TOOLCHAIN_PATH_CC" >&6; }
33130 33130 else
33131 33131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33132 33132 $as_echo "no" >&6; }
33133 33133 fi
33134 33134
33135 33135
33136 33136 test -n "$TOOLCHAIN_PATH_CC" && break
33137 33137 done
33138 33138
33139 33139 CC=$TOOLCHAIN_PATH_CC
33140 33140 PATH="$PATH_save"
33141 33141 fi
33142 33142
33143 33143 # AC_PATH_PROGS can't be run multiple times with the same variable,
33144 33144 # so create a new name for this run.
33145 33145 if test "x$CC" = x; then
33146 33146 for ac_prog in $SEARCH_LIST
33147 33147 do
33148 33148 # Extract the first word of "$ac_prog", so it can be a program name with args.
33149 33149 set dummy $ac_prog; ac_word=$2
33150 33150 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
33151 33151 $as_echo_n "checking for $ac_word... " >&6; }
33152 33152 if ${ac_cv_path_POTENTIAL_CC+:} false; then :
33153 33153 $as_echo_n "(cached) " >&6
33154 33154 else
33155 33155 case $POTENTIAL_CC in
33156 33156 [\\/]* | ?:[\\/]*)
33157 33157 ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
33158 33158 ;;
33159 33159 *)
33160 33160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
33161 33161 for as_dir in $PATH
33162 33162 do
33163 33163 IFS=$as_save_IFS
33164 33164 test -z "$as_dir" && as_dir=.
33165 33165 for ac_exec_ext in '' $ac_executable_extensions; do
33166 33166 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
33167 33167 ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
33168 33168 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
33169 33169 break 2
33170 33170 fi
33171 33171 done
33172 33172 done
33173 33173 IFS=$as_save_IFS
33174 33174
33175 33175 ;;
33176 33176 esac
33177 33177 fi
33178 33178 POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
33179 33179 if test -n "$POTENTIAL_CC"; then
33180 33180 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
33181 33181 $as_echo "$POTENTIAL_CC" >&6; }
33182 33182 else
33183 33183 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33184 33184 $as_echo "no" >&6; }
33185 33185 fi
33186 33186
33187 33187
33188 33188 test -n "$POTENTIAL_CC" && break
33189 33189 done
33190 33190
33191 33191 CC=$POTENTIAL_CC
33192 33192 fi
33193 33193
33194 33194 if test "x$CC" = x; then
33195 33195
33196 33196 # Print a helpful message on how to acquire the necessary build dependency.
33197 33197 # devkit is the help tag: freetype, cups, alsa etc
33198 33198 MISSING_DEPENDENCY=devkit
33199 33199
33200 33200 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33201 33201 cygwin_help $MISSING_DEPENDENCY
33202 33202 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33203 33203 msys_help $MISSING_DEPENDENCY
33204 33204 else
33205 33205 PKGHANDLER_COMMAND=
33206 33206
33207 33207 case $PKGHANDLER in
33208 33208 apt-get)
33209 33209 apt_help $MISSING_DEPENDENCY ;;
33210 33210 yum)
33211 33211 yum_help $MISSING_DEPENDENCY ;;
33212 33212 port)
33213 33213 port_help $MISSING_DEPENDENCY ;;
33214 33214 pkgutil)
33215 33215 pkgutil_help $MISSING_DEPENDENCY ;;
33216 33216 pkgadd)
33217 33217 pkgadd_help $MISSING_DEPENDENCY ;;
33218 33218 esac
33219 33219
33220 33220 if test "x$PKGHANDLER_COMMAND" != x; then
33221 33221 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
33222 33222 fi
33223 33223 fi
33224 33224
33225 33225 as_fn_error $? "Could not find a $COMPILER_NAME compiler. $HELP_MSG" "$LINENO" 5
33226 33226 fi
33227 33227 fi
33228 33228
33229 33229 # Now we have a compiler binary in CC. Make sure it's okay.
33230 33230
33231 33231 # Only process if variable expands to non-empty
33232 33232
33233 33233 if test "x$CC" != x; then
33234 33234 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33235 33235
33236 33236 # First separate the path from the arguments. This will split at the first
33237 33237 # space.
33238 33238 complete="$CC"
33239 33239 path="${complete%% *}"
33240 33240 tmp="$complete EOL"
33241 33241 arguments="${tmp#* }"
33242 33242
33243 33243 # Input might be given as Windows format, start by converting to
33244 33244 # unix format.
33245 33245 new_path=`$CYGPATH -u "$path"`
33246 33246
33247 33247 # Now try to locate executable using which
33248 33248 new_path=`$WHICH "$new_path" 2> /dev/null`
33249 33249 # bat and cmd files are not always considered executable in cygwin causing which
33250 33250 # to not find them
33251 33251 if test "x$new_path" = x \
33252 33252 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
33253 33253 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
33254 33254 new_path=`$CYGPATH -u "$path"`
33255 33255 fi
33256 33256 if test "x$new_path" = x; then
33257 33257 # Oops. Which didn't find the executable.
33258 33258 # The splitting of arguments from the executable at a space might have been incorrect,
33259 33259 # since paths with space are more likely in Windows. Give it another try with the whole
33260 33260 # argument.
33261 33261 path="$complete"
33262 33262 arguments="EOL"
33263 33263 new_path=`$CYGPATH -u "$path"`
33264 33264 new_path=`$WHICH "$new_path" 2> /dev/null`
33265 33265 # bat and cmd files are not always considered executable in cygwin causing which
33266 33266 # to not find them
33267 33267 if test "x$new_path" = x \
33268 33268 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
33269 33269 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
33270 33270 new_path=`$CYGPATH -u "$path"`
33271 33271 fi
33272 33272 if test "x$new_path" = x; then
33273 33273 # It's still not found. Now this is an unrecoverable error.
33274 33274 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
33275 33275 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
33276 33276 has_space=`$ECHO "$complete" | $GREP " "`
33277 33277 if test "x$has_space" != x; then
33278 33278 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33279 33279 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33280 33280 fi
33281 33281 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
33282 33282 fi
33283 33283 fi
33284 33284
33285 33285 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
33286 33286 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
33287 33287 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
33288 33288 # "foo.exe" is OK but "foo" is an error.
33289 33289 #
33290 33290 # This test is therefore slightly more accurate than "test -f" to check for file presence.
33291 33291 # It is also a way to make sure we got the proper file name for the real test later on.
33292 33292 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
33293 33293 if test "x$test_shortpath" = x; then
33294 33294 # Short path failed, file does not exist as specified.
33295 33295 # Try adding .exe or .cmd
33296 33296 if test -f "${new_path}.exe"; then
33297 33297 input_to_shortpath="${new_path}.exe"
33298 33298 elif test -f "${new_path}.cmd"; then
33299 33299 input_to_shortpath="${new_path}.cmd"
33300 33300 else
33301 33301 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
33302 33302 $as_echo "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
33303 33303 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
33304 33304 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
33305 33305 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
33306 33306 fi
33307 33307 else
33308 33308 input_to_shortpath="$new_path"
33309 33309 fi
33310 33310
33311 33311 # Call helper function which possibly converts this using DOS-style short mode.
33312 33312 # If so, the updated path is stored in $new_path.
33313 33313 new_path="$input_to_shortpath"
33314 33314
33315 33315 input_path="$input_to_shortpath"
33316 33316 # Check if we need to convert this using DOS-style short mode. If the path
33317 33317 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33318 33318 # take no chances and rewrite it.
33319 33319 # Note: m4 eats our [], so we need to use [ and ] instead.
33320 33320 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33321 33321 if test "x$has_forbidden_chars" != x; then
33322 33322 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33323 33323 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33324 33324 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33325 33325 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33326 33326 # Going to short mode and back again did indeed matter. Since short mode is
33327 33327 # case insensitive, let's make it lowercase to improve readability.
33328 33328 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33329 33329 # Now convert it back to Unix-style (cygpath)
33330 33330 input_path=`$CYGPATH -u "$shortmode_path"`
33331 33331 new_path="$input_path"
33332 33332 fi
33333 33333 fi
33334 33334
33335 33335 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33336 33336 if test "x$test_cygdrive_prefix" = x; then
33337 33337 # As a simple fix, exclude /usr/bin since it's not a real path.
33338 33338 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33339 33339 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33340 33340 # a path prefixed by /cygdrive for fixpath to work.
33341 33341 new_path="$CYGWIN_ROOT_PATH$input_path"
33342 33342 fi
33343 33343 fi
33344 33344
33345 33345 # remove trailing .exe if any
33346 33346 new_path="${new_path/%.exe/}"
33347 33347
33348 33348 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33349 33349
33350 33350 # First separate the path from the arguments. This will split at the first
33351 33351 # space.
33352 33352 complete="$CC"
33353 33353 path="${complete%% *}"
33354 33354 tmp="$complete EOL"
33355 33355 arguments="${tmp#* }"
33356 33356
33357 33357 # Input might be given as Windows format, start by converting to
33358 33358 # unix format.
33359 33359 new_path="$path"
33360 33360
33361 33361 windows_path="$new_path"
33362 33362 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33363 33363 unix_path=`$CYGPATH -u "$windows_path"`
33364 33364 new_path="$unix_path"
33365 33365 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33366 33366 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33367 33367 new_path="$unix_path"
33368 33368 fi
33369 33369
33370 33370
33371 33371 # Now try to locate executable using which
33372 33372 new_path=`$WHICH "$new_path" 2> /dev/null`
33373 33373
33374 33374 if test "x$new_path" = x; then
33375 33375 # Oops. Which didn't find the executable.
33376 33376 # The splitting of arguments from the executable at a space might have been incorrect,
33377 33377 # since paths with space are more likely in Windows. Give it another try with the whole
33378 33378 # argument.
33379 33379 path="$complete"
33380 33380 arguments="EOL"
33381 33381 new_path="$path"
33382 33382
33383 33383 windows_path="$new_path"
33384 33384 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33385 33385 unix_path=`$CYGPATH -u "$windows_path"`
33386 33386 new_path="$unix_path"
33387 33387 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33388 33388 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33389 33389 new_path="$unix_path"
33390 33390 fi
33391 33391
33392 33392
33393 33393 new_path=`$WHICH "$new_path" 2> /dev/null`
33394 33394 # bat and cmd files are not always considered executable in MSYS causing which
33395 33395 # to not find them
33396 33396 if test "x$new_path" = x \
33397 33397 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
33398 33398 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
33399 33399 new_path="$path"
33400 33400
33401 33401 windows_path="$new_path"
33402 33402 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33403 33403 unix_path=`$CYGPATH -u "$windows_path"`
33404 33404 new_path="$unix_path"
33405 33405 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33406 33406 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33407 33407 new_path="$unix_path"
33408 33408 fi
33409 33409
33410 33410 fi
33411 33411
33412 33412 if test "x$new_path" = x; then
33413 33413 # It's still not found. Now this is an unrecoverable error.
33414 33414 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
33415 33415 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
33416 33416 has_space=`$ECHO "$complete" | $GREP " "`
33417 33417 if test "x$has_space" != x; then
33418 33418 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
33419 33419 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
33420 33420 fi
33421 33421 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
33422 33422 fi
33423 33423 fi
33424 33424
33425 33425 # Now new_path has a complete unix path to the binary
33426 33426 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
33427 33427 # Keep paths in /bin as-is, but remove trailing .exe if any
33428 33428 new_path="${new_path/%.exe/}"
33429 33429 # Do not save /bin paths to all_fixpath_prefixes!
33430 33430 else
33431 33431 # Not in mixed or Windows style, start by that.
33432 33432 new_path=`cmd //c echo $new_path`
33433 33433
33434 33434 input_path="$new_path"
33435 33435 # Check if we need to convert this using DOS-style short mode. If the path
33436 33436 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33437 33437 # take no chances and rewrite it.
33438 33438 # Note: m4 eats our [], so we need to use [ and ] instead.
33439 33439 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
33440 33440 if test "x$has_forbidden_chars" != x; then
33441 33441 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33442 33442 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33443 33443 fi
33444 33444
33445 33445 # Output is in $new_path
33446 33446
33447 33447 windows_path="$new_path"
33448 33448 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33449 33449 unix_path=`$CYGPATH -u "$windows_path"`
33450 33450 new_path="$unix_path"
33451 33451 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33452 33452 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33453 33453 new_path="$unix_path"
33454 33454 fi
33455 33455
33456 33456 # remove trailing .exe if any
33457 33457 new_path="${new_path/%.exe/}"
33458 33458
33459 33459 # Save the first 10 bytes of this path to the storage, so fixpath can work.
33460 33460 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
33461 33461 fi
33462 33462
33463 33463 else
33464 33464 # We're on a unix platform. Hooray! :)
33465 33465 # First separate the path from the arguments. This will split at the first
33466 33466 # space.
33467 33467 complete="$CC"
33468 33468 path="${complete%% *}"
33469 33469 tmp="$complete EOL"
33470 33470 arguments="${tmp#* }"
33471 33471
33472 33472 # Cannot rely on the command "which" here since it doesn't always work.
33473 33473 is_absolute_path=`$ECHO "$path" | $GREP ^/`
33474 33474 if test -z "$is_absolute_path"; then
33475 33475 # Path to executable is not absolute. Find it.
33476 33476 IFS_save="$IFS"
33477 33477 IFS=:
33478 33478 for p in $PATH; do
33479 33479 if test -f "$p/$path" && test -x "$p/$path"; then
33480 33480 new_path="$p/$path"
33481 33481 break
33482 33482 fi
33483 33483 done
33484 33484 IFS="$IFS_save"
33485 33485 else
33486 33486 # This is an absolute path, we can use it without further modifications.
33487 33487 new_path="$path"
33488 33488 fi
33489 33489
33490 33490 if test "x$new_path" = x; then
33491 33491 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
33492 33492 $as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
33493 33493 has_space=`$ECHO "$complete" | $GREP " "`
33494 33494 if test "x$has_space" != x; then
33495 33495 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
33496 33496 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
33497 33497 fi
33498 33498 as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
33499 33499 fi
33500 33500 fi
33501 33501
33502 33502 # Now join together the path and the arguments once again
33503 33503 if test "x$arguments" != xEOL; then
33504 33504 new_complete="$new_path ${arguments% *}"
33505 33505 else
33506 33506 new_complete="$new_path"
33507 33507 fi
33508 33508
33509 33509 if test "x$complete" != "x$new_complete"; then
33510 33510 CC="$new_complete"
33511 33511 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
33512 33512 $as_echo "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
33513 33513 fi
33514 33514 fi
33515 33515
33516 33516 TEST_COMPILER="$CC"
33517 33517
33518 33518 { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
33519 33519 $as_echo_n "checking resolved symbolic links for CC... " >&6; }
33520 33520 SYMLINK_ORIGINAL="$TEST_COMPILER"
33521 33521
33522 33522 if test "x$OPENJDK_BUILD_OS" != xwindows; then
33523 33523 # Follow a chain of symbolic links. Use readlink
33524 33524 # where it exists, else fall back to horribly
33525 33525 # complicated shell code.
33526 33526 if test "x$READLINK_TESTED" != yes; then
33527 33527 # On MacOSX there is a readlink tool with a different
33528 33528 # purpose than the GNU readlink tool. Check the found readlink.
33529 33529 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
33530 33530 if test "x$ISGNU" = x; then
33531 33531 # A readlink that we do not know how to use.
33532 33532 # Are there other non-GNU readlinks out there?
33533 33533 READLINK_TESTED=yes
33534 33534 READLINK=
33535 33535 fi
33536 33536 fi
33537 33537
33538 33538 if test "x$READLINK" != x; then
33539 33539 SYMLINK_ORIGINAL=`$READLINK -f $SYMLINK_ORIGINAL`
33540 33540 else
33541 33541 # Save the current directory for restoring afterwards
33542 33542 STARTDIR=$PWD
33543 33543 COUNTER=0
33544 33544 sym_link_dir=`$DIRNAME $SYMLINK_ORIGINAL`
33545 33545 sym_link_file=`$BASENAME $SYMLINK_ORIGINAL`
33546 33546 cd $sym_link_dir
33547 33547 # Use -P flag to resolve symlinks in directories.
33548 33548 cd `$THEPWDCMD -P`
33549 33549 sym_link_dir=`$THEPWDCMD -P`
33550 33550 # Resolve file symlinks
33551 33551 while test $COUNTER -lt 20; do
33552 33552 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
33553 33553 if test "x$ISLINK" == x; then
33554 33554 # This is not a symbolic link! We are done!
33555 33555 break
33556 33556 fi
33557 33557 # Again resolve directory symlinks since the target of the just found
33558 33558 # link could be in a different directory
33559 33559 cd `$DIRNAME $ISLINK`
33560 33560 sym_link_dir=`$THEPWDCMD -P`
33561 33561 sym_link_file=`$BASENAME $ISLINK`
33562 33562 let COUNTER=COUNTER+1
33563 33563 done
33564 33564 cd $STARTDIR
33565 33565 SYMLINK_ORIGINAL=$sym_link_dir/$sym_link_file
33566 33566 fi
33567 33567 fi
33568 33568
33569 33569 if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
33570 33570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
33571 33571 $as_echo "no symlink" >&6; }
33572 33572 else
33573 33573 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
33574 33574 $as_echo "$SYMLINK_ORIGINAL" >&6; }
33575 33575
33576 33576 # We can't handle ccache by gcc wrappers, since we need to know if we're
33577 33577 # using ccache. Instead ccache usage must be controlled by a configure option.
33578 33578 COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
33579 33579 if test "x$COMPILER_BASENAME" = "xccache"; then
33580 33580 { $as_echo "$as_me:${as_lineno-$LINENO}: Please use --enable-ccache instead of providing a wrapped compiler." >&5
33581 33581 $as_echo "$as_me: Please use --enable-ccache instead of providing a wrapped compiler." >&6;}
33582 33582 as_fn_error $? "$TEST_COMPILER is a symbolic link to ccache. This is not supported." "$LINENO" 5
33583 33583 fi
33584 33584 fi
33585 33585
33586 33586
33587 33587 COMPILER=$CC
33588 33588 COMPILER_NAME=$COMPILER_NAME
33589 33589
33590 33590 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
33591 33591 # cc -V output typically looks like
33592 33592 # cc: Sun C 5.12 Linux_i386 2011/11/16
33593 33593 COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
33594 33594 # Check that this is likely to be the Solaris Studio cc.
33595 33595 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
33596 33596 if test $? -ne 0; then
33597 33597 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
33598 33598 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
33599 33599 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
33600 33600 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
33601 33601 $as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
33602 33602 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
33603 33603 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
33604 33604 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
33605 33605 fi
33606 33606 # Remove usage instructions (if present), and
33607 33607 # collapse compiler output into a single line
33608 33608 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
33609 33609 $SED -e 's/ *[Uu]sage:.*//'`
33610 33610 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
33611 33611 $SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
33612 33612 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
33613 33613 # xlc -qversion output typically looks like
33614 33614 # IBM XL C/C++ for AIX, V11.1 (5724-X13)
33615 33615 # Version: 11.01.0000.0015
33616 33616 COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
33617 33617 # Check that this is likely to be the IBM XL C compiler.
33618 33618 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
33619 33619 if test $? -ne 0; then
33620 33620 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
33621 33621 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
33622 33622 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
33623 33623 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
33624 33624 $as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
33625 33625 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
33626 33626 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
33627 33627 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
33628 33628 fi
33629 33629 # Collapse compiler output into a single line
33630 33630 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
33631 33631 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
33632 33632 $SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
33633 33633 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
33634 33634 # There is no specific version flag, but all output starts with a version string.
33635 33635 # First line typically looks something like:
33636 33636 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
33637 33637 COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
33638 33638 # Check that this is likely to be Microsoft CL.EXE.
33639 33639 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
33640 33640 if test $? -ne 0; then
33641 33641 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
33642 33642 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
33643 33643 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
33644 33644 $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
33645 33645 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
33646 33646 fi
33647 33647 # Collapse compiler output into a single line
33648 33648 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
33649 33649 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
33650 33650 $SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
33651 33651 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
33652 33652 # gcc --version output typically looks like
33653 33653 # gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
33654 33654 # Copyright (C) 2013 Free Software Foundation, Inc.
33655 33655 # This is free software; see the source for copying conditions. There is NO
33656 33656 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
33657 33657 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
33658 33658 # Check that this is likely to be GCC.
33659 33659 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
33660 33660 if test $? -ne 0; then
33661 33661 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
33662 33662 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
33663 33663 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
33664 33664 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
33665 33665 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
33666 33666 fi
33667 33667 # Remove Copyright and legalese from version string, and
33668 33668 # collapse into a single line
33669 33669 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
33670 33670 $SED -e 's/ *Copyright .*//'`
33671 33671 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
33672 33672 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
33673 33673 elif test "x$TOOLCHAIN_TYPE" = xclang; then
33674 33674 # clang --version output typically looks like
33675 33675 # Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
33676 33676 # clang version 3.3 (tags/RELEASE_33/final)
33677 33677 # or
33678 33678 # Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
33679 33679 # Target: x86_64-pc-linux-gnu
33680 33680 # Thread model: posix
33681 33681 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
33682 33682 # Check that this is likely to be clang
33683 33683 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
33684 33684 if test $? -ne 0; then
33685 33685 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
33686 33686 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
33687 33687 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
33688 33688 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
33689 33689 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
33690 33690 fi
33691 33691 # Collapse compiler output into a single line
33692 33692 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
33693 33693 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
33694 33694 $SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
33695 33695 else
33696 33696 as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
33697 33697 fi
33698 33698 # This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
33699 33699 CC_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
33700 33700 # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
33701 33701 CC_VERSION_STRING="$COMPILER_VERSION_STRING"
33702 33702
33703 33703 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
33704 33704 $as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
33705 33705
33706 33706
33707 33707 # Now that we have resolved CC ourself, let autoconf have its go at it
33708 33708 ac_ext=c
33709 33709 ac_cpp='$CPP $CPPFLAGS'
33710 33710 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
33711 33711 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
33712 33712 ac_compiler_gnu=$ac_cv_c_compiler_gnu
33713 33713 if test -n "$ac_tool_prefix"; then
33714 33714 for ac_prog in $CC
33715 33715 do
33716 33716 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
33717 33717 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
33718 33718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
33719 33719 $as_echo_n "checking for $ac_word... " >&6; }
33720 33720 if ${ac_cv_prog_CC+:} false; then :
33721 33721 $as_echo_n "(cached) " >&6
33722 33722 else
33723 33723 if test -n "$CC"; then
33724 33724 ac_cv_prog_CC="$CC" # Let the user override the test.
33725 33725 else
33726 33726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
33727 33727 for as_dir in $PATH
33728 33728 do
33729 33729 IFS=$as_save_IFS
33730 33730 test -z "$as_dir" && as_dir=.
33731 33731 for ac_exec_ext in '' $ac_executable_extensions; do
33732 33732 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
33733 33733 ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
33734 33734 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
33735 33735 break 2
33736 33736 fi
33737 33737 done
33738 33738 done
33739 33739 IFS=$as_save_IFS
33740 33740
33741 33741 fi
33742 33742 fi
33743 33743 CC=$ac_cv_prog_CC
33744 33744 if test -n "$CC"; then
33745 33745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
33746 33746 $as_echo "$CC" >&6; }
33747 33747 else
33748 33748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33749 33749 $as_echo "no" >&6; }
33750 33750 fi
33751 33751
33752 33752
33753 33753 test -n "$CC" && break
33754 33754 done
33755 33755 fi
33756 33756 if test -z "$CC"; then
33757 33757 ac_ct_CC=$CC
33758 33758 for ac_prog in $CC
33759 33759 do
33760 33760 # Extract the first word of "$ac_prog", so it can be a program name with args.
33761 33761 set dummy $ac_prog; ac_word=$2
33762 33762 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
33763 33763 $as_echo_n "checking for $ac_word... " >&6; }
33764 33764 if ${ac_cv_prog_ac_ct_CC+:} false; then :
33765 33765 $as_echo_n "(cached) " >&6
33766 33766 else
33767 33767 if test -n "$ac_ct_CC"; then
33768 33768 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
33769 33769 else
33770 33770 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
33771 33771 for as_dir in $PATH
33772 33772 do
33773 33773 IFS=$as_save_IFS
33774 33774 test -z "$as_dir" && as_dir=.
33775 33775 for ac_exec_ext in '' $ac_executable_extensions; do
33776 33776 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
33777 33777 ac_cv_prog_ac_ct_CC="$ac_prog"
33778 33778 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
33779 33779 break 2
33780 33780 fi
33781 33781 done
33782 33782 done
33783 33783 IFS=$as_save_IFS
33784 33784
33785 33785 fi
33786 33786 fi
33787 33787 ac_ct_CC=$ac_cv_prog_ac_ct_CC
33788 33788 if test -n "$ac_ct_CC"; then
33789 33789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
33790 33790 $as_echo "$ac_ct_CC" >&6; }
33791 33791 else
33792 33792 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33793 33793 $as_echo "no" >&6; }
33794 33794 fi
33795 33795
33796 33796
33797 33797 test -n "$ac_ct_CC" && break
33798 33798 done
33799 33799
33800 33800 if test "x$ac_ct_CC" = x; then
33801 33801 CC=""
33802 33802 else
33803 33803 case $cross_compiling:$ac_tool_warned in
33804 33804 yes:)
33805 33805 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
33806 33806 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
33807 33807 ac_tool_warned=yes ;;
33808 33808 esac
33809 33809 CC=$ac_ct_CC
33810 33810 fi
33811 33811 fi
33812 33812
33813 33813
33814 33814 test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
33815 33815 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
33816 33816 as_fn_error $? "no acceptable C compiler found in \$PATH
33817 33817 See \`config.log' for more details" "$LINENO" 5; }
33818 33818
33819 33819 # Provide some information about the compiler.
33820 33820 $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
33821 33821 set X $ac_compile
33822 33822 ac_compiler=$2
33823 33823 for ac_option in --version -v -V -qversion; do
33824 33824 { { ac_try="$ac_compiler $ac_option >&5"
33825 33825 case "(($ac_try" in
33826 33826 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
33827 33827 *) ac_try_echo=$ac_try;;
33828 33828 esac
33829 33829 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
33830 33830 $as_echo "$ac_try_echo"; } >&5
33831 33831 (eval "$ac_compiler $ac_option >&5") 2>conftest.err
33832 33832 ac_status=$?
33833 33833 if test -s conftest.err; then
33834 33834 sed '10a\
33835 33835 ... rest of stderr output deleted ...
33836 33836 10q' conftest.err >conftest.er1
33837 33837 cat conftest.er1 >&5
33838 33838 fi
33839 33839 rm -f conftest.er1 conftest.err
33840 33840 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
33841 33841 test $ac_status = 0; }
33842 33842 done
33843 33843
33844 33844 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
33845 33845 /* end confdefs.h. */
33846 33846
33847 33847 int
33848 33848 main ()
33849 33849 {
33850 33850
33851 33851 ;
33852 33852 return 0;
33853 33853 }
33854 33854 _ACEOF
33855 33855 ac_clean_files_save=$ac_clean_files
33856 33856 ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
33857 33857 # Try to create an executable without -o first, disregard a.out.
33858 33858 # It will help us diagnose broken compilers, and finding out an intuition
33859 33859 # of exeext.
33860 33860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
33861 33861 $as_echo_n "checking whether the C compiler works... " >&6; }
33862 33862 ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
33863 33863
33864 33864 # The possible output files:
33865 33865 ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
33866 33866
33867 33867 ac_rmfiles=
33868 33868 for ac_file in $ac_files
33869 33869 do
33870 33870 case $ac_file in
33871 33871 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
33872 33872 * ) ac_rmfiles="$ac_rmfiles $ac_file";;
33873 33873 esac
33874 33874 done
33875 33875 rm -f $ac_rmfiles
33876 33876
33877 33877 if { { ac_try="$ac_link_default"
33878 33878 case "(($ac_try" in
33879 33879 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
33880 33880 *) ac_try_echo=$ac_try;;
33881 33881 esac
33882 33882 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
33883 33883 $as_echo "$ac_try_echo"; } >&5
33884 33884 (eval "$ac_link_default") 2>&5
33885 33885 ac_status=$?
33886 33886 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
33887 33887 test $ac_status = 0; }; then :
33888 33888 # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
33889 33889 # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
33890 33890 # in a Makefile. We should not override ac_cv_exeext if it was cached,
33891 33891 # so that the user can short-circuit this test for compilers unknown to
33892 33892 # Autoconf.
33893 33893 for ac_file in $ac_files ''
33894 33894 do
33895 33895 test -f "$ac_file" || continue
33896 33896 case $ac_file in
33897 33897 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
33898 33898 ;;
33899 33899 [ab].out )
33900 33900 # We found the default executable, but exeext='' is most
33901 33901 # certainly right.
33902 33902 break;;
33903 33903 *.* )
33904 33904 if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
33905 33905 then :; else
33906 33906 ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
33907 33907 fi
33908 33908 # We set ac_cv_exeext here because the later test for it is not
33909 33909 # safe: cross compilers may not add the suffix if given an `-o'
33910 33910 # argument, so we may need to know it at that point already.
33911 33911 # Even if this section looks crufty: it has the advantage of
33912 33912 # actually working.
33913 33913 break;;
33914 33914 * )
33915 33915 break;;
33916 33916 esac
33917 33917 done
33918 33918 test "$ac_cv_exeext" = no && ac_cv_exeext=
33919 33919
33920 33920 else
33921 33921 ac_file=''
33922 33922 fi
33923 33923 if test -z "$ac_file"; then :
33924 33924 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
33925 33925 $as_echo "no" >&6; }
33926 33926 $as_echo "$as_me: failed program was:" >&5
33927 33927 sed 's/^/| /' conftest.$ac_ext >&5
33928 33928
33929 33929 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
33930 33930 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
33931 33931 as_fn_error 77 "C compiler cannot create executables
33932 33932 See \`config.log' for more details" "$LINENO" 5; }
33933 33933 else
33934 33934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
33935 33935 $as_echo "yes" >&6; }
33936 33936 fi
33937 33937 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
33938 33938 $as_echo_n "checking for C compiler default output file name... " >&6; }
33939 33939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
33940 33940 $as_echo "$ac_file" >&6; }
33941 33941 ac_exeext=$ac_cv_exeext
33942 33942
33943 33943 rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
33944 33944 ac_clean_files=$ac_clean_files_save
33945 33945 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
33946 33946 $as_echo_n "checking for suffix of executables... " >&6; }
33947 33947 if { { ac_try="$ac_link"
33948 33948 case "(($ac_try" in
33949 33949 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
33950 33950 *) ac_try_echo=$ac_try;;
33951 33951 esac
33952 33952 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
33953 33953 $as_echo "$ac_try_echo"; } >&5
33954 33954 (eval "$ac_link") 2>&5
33955 33955 ac_status=$?
33956 33956 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
33957 33957 test $ac_status = 0; }; then :
33958 33958 # If both `conftest.exe' and `conftest' are `present' (well, observable)
33959 33959 # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
33960 33960 # work properly (i.e., refer to `conftest.exe'), while it won't with
33961 33961 # `rm'.
33962 33962 for ac_file in conftest.exe conftest conftest.*; do
33963 33963 test -f "$ac_file" || continue
33964 33964 case $ac_file in
33965 33965 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
33966 33966 *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
33967 33967 break;;
33968 33968 * ) break;;
33969 33969 esac
33970 33970 done
33971 33971 else
33972 33972 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
33973 33973 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
33974 33974 as_fn_error $? "cannot compute suffix of executables: cannot compile and link
33975 33975 See \`config.log' for more details" "$LINENO" 5; }
33976 33976 fi
33977 33977 rm -f conftest conftest$ac_cv_exeext
33978 33978 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
33979 33979 $as_echo "$ac_cv_exeext" >&6; }
33980 33980
33981 33981 rm -f conftest.$ac_ext
33982 33982 EXEEXT=$ac_cv_exeext
33983 33983 ac_exeext=$EXEEXT
33984 33984 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
33985 33985 /* end confdefs.h. */
33986 33986 #include <stdio.h>
33987 33987 int
33988 33988 main ()
33989 33989 {
33990 33990 FILE *f = fopen ("conftest.out", "w");
33991 33991 return ferror (f) || fclose (f) != 0;
33992 33992
33993 33993 ;
33994 33994 return 0;
33995 33995 }
33996 33996 _ACEOF
33997 33997 ac_clean_files="$ac_clean_files conftest.out"
33998 33998 # Check that the compiler produces executables we can run. If not, either
33999 33999 # the compiler is broken, or we cross compile.
34000 34000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
34001 34001 $as_echo_n "checking whether we are cross compiling... " >&6; }
34002 34002 if test "$cross_compiling" != yes; then
34003 34003 { { ac_try="$ac_link"
34004 34004 case "(($ac_try" in
34005 34005 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
34006 34006 *) ac_try_echo=$ac_try;;
34007 34007 esac
34008 34008 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
34009 34009 $as_echo "$ac_try_echo"; } >&5
34010 34010 (eval "$ac_link") 2>&5
34011 34011 ac_status=$?
34012 34012 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
34013 34013 test $ac_status = 0; }
34014 34014 if { ac_try='./conftest$ac_cv_exeext'
34015 34015 { { case "(($ac_try" in
34016 34016 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
34017 34017 *) ac_try_echo=$ac_try;;
34018 34018 esac
34019 34019 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
34020 34020 $as_echo "$ac_try_echo"; } >&5
34021 34021 (eval "$ac_try") 2>&5
34022 34022 ac_status=$?
34023 34023 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
34024 34024 test $ac_status = 0; }; }; then
34025 34025 cross_compiling=no
34026 34026 else
34027 34027 if test "$cross_compiling" = maybe; then
34028 34028 cross_compiling=yes
34029 34029 else
34030 34030 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
34031 34031 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
34032 34032 as_fn_error $? "cannot run C compiled programs.
34033 34033 If you meant to cross compile, use \`--host'.
34034 34034 See \`config.log' for more details" "$LINENO" 5; }
34035 34035 fi
34036 34036 fi
34037 34037 fi
34038 34038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
34039 34039 $as_echo "$cross_compiling" >&6; }
34040 34040
34041 34041 rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
34042 34042 ac_clean_files=$ac_clean_files_save
34043 34043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
34044 34044 $as_echo_n "checking for suffix of object files... " >&6; }
34045 34045 if ${ac_cv_objext+:} false; then :
34046 34046 $as_echo_n "(cached) " >&6
34047 34047 else
34048 34048 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34049 34049 /* end confdefs.h. */
34050 34050
34051 34051 int
34052 34052 main ()
34053 34053 {
34054 34054
34055 34055 ;
34056 34056 return 0;
34057 34057 }
34058 34058 _ACEOF
34059 34059 rm -f conftest.o conftest.obj
34060 34060 if { { ac_try="$ac_compile"
34061 34061 case "(($ac_try" in
34062 34062 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
34063 34063 *) ac_try_echo=$ac_try;;
34064 34064 esac
34065 34065 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
34066 34066 $as_echo "$ac_try_echo"; } >&5
34067 34067 (eval "$ac_compile") 2>&5
34068 34068 ac_status=$?
34069 34069 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
34070 34070 test $ac_status = 0; }; then :
34071 34071 for ac_file in conftest.o conftest.obj conftest.*; do
34072 34072 test -f "$ac_file" || continue;
34073 34073 case $ac_file in
34074 34074 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
34075 34075 *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
34076 34076 break;;
34077 34077 esac
34078 34078 done
34079 34079 else
34080 34080 $as_echo "$as_me: failed program was:" >&5
34081 34081 sed 's/^/| /' conftest.$ac_ext >&5
34082 34082
34083 34083 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
34084 34084 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
34085 34085 as_fn_error $? "cannot compute suffix of object files: cannot compile
34086 34086 See \`config.log' for more details" "$LINENO" 5; }
34087 34087 fi
34088 34088 rm -f conftest.$ac_cv_objext conftest.$ac_ext
34089 34089 fi
34090 34090 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
34091 34091 $as_echo "$ac_cv_objext" >&6; }
34092 34092 OBJEXT=$ac_cv_objext
34093 34093 ac_objext=$OBJEXT
34094 34094 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
34095 34095 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
34096 34096 if ${ac_cv_c_compiler_gnu+:} false; then :
34097 34097 $as_echo_n "(cached) " >&6
34098 34098 else
34099 34099 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34100 34100 /* end confdefs.h. */
34101 34101
34102 34102 int
34103 34103 main ()
34104 34104 {
34105 34105 #ifndef __GNUC__
34106 34106 choke me
34107 34107 #endif
34108 34108
34109 34109 ;
34110 34110 return 0;
34111 34111 }
34112 34112 _ACEOF
34113 34113 if ac_fn_c_try_compile "$LINENO"; then :
34114 34114 ac_compiler_gnu=yes
34115 34115 else
34116 34116 ac_compiler_gnu=no
34117 34117 fi
34118 34118 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
34119 34119 ac_cv_c_compiler_gnu=$ac_compiler_gnu
34120 34120
34121 34121 fi
34122 34122 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
34123 34123 $as_echo "$ac_cv_c_compiler_gnu" >&6; }
34124 34124 if test $ac_compiler_gnu = yes; then
34125 34125 GCC=yes
34126 34126 else
34127 34127 GCC=
34128 34128 fi
34129 34129 ac_test_CFLAGS=${CFLAGS+set}
34130 34130 ac_save_CFLAGS=$CFLAGS
34131 34131 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
34132 34132 $as_echo_n "checking whether $CC accepts -g... " >&6; }
34133 34133 if ${ac_cv_prog_cc_g+:} false; then :
34134 34134 $as_echo_n "(cached) " >&6
34135 34135 else
34136 34136 ac_save_c_werror_flag=$ac_c_werror_flag
34137 34137 ac_c_werror_flag=yes
34138 34138 ac_cv_prog_cc_g=no
34139 34139 CFLAGS="-g"
34140 34140 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34141 34141 /* end confdefs.h. */
34142 34142
34143 34143 int
34144 34144 main ()
34145 34145 {
34146 34146
34147 34147 ;
34148 34148 return 0;
34149 34149 }
34150 34150 _ACEOF
34151 34151 if ac_fn_c_try_compile "$LINENO"; then :
34152 34152 ac_cv_prog_cc_g=yes
34153 34153 else
34154 34154 CFLAGS=""
34155 34155 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34156 34156 /* end confdefs.h. */
34157 34157
34158 34158 int
34159 34159 main ()
34160 34160 {
34161 34161
34162 34162 ;
34163 34163 return 0;
34164 34164 }
34165 34165 _ACEOF
34166 34166 if ac_fn_c_try_compile "$LINENO"; then :
34167 34167
34168 34168 else
34169 34169 ac_c_werror_flag=$ac_save_c_werror_flag
34170 34170 CFLAGS="-g"
34171 34171 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34172 34172 /* end confdefs.h. */
34173 34173
34174 34174 int
34175 34175 main ()
34176 34176 {
34177 34177
34178 34178 ;
34179 34179 return 0;
34180 34180 }
34181 34181 _ACEOF
34182 34182 if ac_fn_c_try_compile "$LINENO"; then :
34183 34183 ac_cv_prog_cc_g=yes
34184 34184 fi
34185 34185 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
34186 34186 fi
34187 34187 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
34188 34188 fi
34189 34189 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
34190 34190 ac_c_werror_flag=$ac_save_c_werror_flag
34191 34191 fi
34192 34192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
34193 34193 $as_echo "$ac_cv_prog_cc_g" >&6; }
34194 34194 if test "$ac_test_CFLAGS" = set; then
34195 34195 CFLAGS=$ac_save_CFLAGS
34196 34196 elif test $ac_cv_prog_cc_g = yes; then
34197 34197 if test "$GCC" = yes; then
34198 34198 CFLAGS="-g -O2"
34199 34199 else
34200 34200 CFLAGS="-g"
34201 34201 fi
34202 34202 else
34203 34203 if test "$GCC" = yes; then
34204 34204 CFLAGS="-O2"
34205 34205 else
34206 34206 CFLAGS=
34207 34207 fi
34208 34208 fi
34209 34209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
34210 34210 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
34211 34211 if ${ac_cv_prog_cc_c89+:} false; then :
34212 34212 $as_echo_n "(cached) " >&6
34213 34213 else
34214 34214 ac_cv_prog_cc_c89=no
34215 34215 ac_save_CC=$CC
34216 34216 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
34217 34217 /* end confdefs.h. */
34218 34218 #include <stdarg.h>
34219 34219 #include <stdio.h>
34220 34220 struct stat;
34221 34221 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
34222 34222 struct buf { int x; };
34223 34223 FILE * (*rcsopen) (struct buf *, struct stat *, int);
34224 34224 static char *e (p, i)
34225 34225 char **p;
34226 34226 int i;
34227 34227 {
34228 34228 return p[i];
34229 34229 }
34230 34230 static char *f (char * (*g) (char **, int), char **p, ...)
34231 34231 {
34232 34232 char *s;
34233 34233 va_list v;
34234 34234 va_start (v,p);
34235 34235 s = g (p, va_arg (v,int));
34236 34236 va_end (v);
34237 34237 return s;
34238 34238 }
34239 34239
34240 34240 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
34241 34241 function prototypes and stuff, but not '\xHH' hex character constants.
34242 34242 These don't provoke an error unfortunately, instead are silently treated
34243 34243 as 'x'. The following induces an error, until -std is added to get
34244 34244 proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
34245 34245 array size at least. It's necessary to write '\x00'==0 to get something
34246 34246 that's true only with -std. */
34247 34247 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
34248 34248
34249 34249 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
34250 34250 inside strings and character constants. */
34251 34251 #define FOO(x) 'x'
34252 34252 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
34253 34253
34254 34254 int test (int i, double x);
34255 34255 struct s1 {int (*f) (int a);};
34256 34256 struct s2 {int (*f) (double a);};
34257 34257 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
34258 34258 int argc;
34259 34259 char **argv;
34260 34260 int
34261 34261 main ()
34262 34262 {
34263 34263 return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];
34264 34264 ;
34265 34265 return 0;
34266 34266 }
34267 34267 _ACEOF
34268 34268 for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
34269 34269 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
34270 34270 do
34271 34271 CC="$ac_save_CC $ac_arg"
34272 34272 if ac_fn_c_try_compile "$LINENO"; then :
34273 34273 ac_cv_prog_cc_c89=$ac_arg
34274 34274 fi
34275 34275 rm -f core conftest.err conftest.$ac_objext
34276 34276 test "x$ac_cv_prog_cc_c89" != "xno" && break
34277 34277 done
34278 34278 rm -f conftest.$ac_ext
34279 34279 CC=$ac_save_CC
34280 34280
34281 34281 fi
34282 34282 # AC_CACHE_VAL
34283 34283 case "x$ac_cv_prog_cc_c89" in
34284 34284 x)
34285 34285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
34286 34286 $as_echo "none needed" >&6; } ;;
34287 34287 xno)
34288 34288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
34289 34289 $as_echo "unsupported" >&6; } ;;
34290 34290 *)
34291 34291 CC="$CC $ac_cv_prog_cc_c89"
34292 34292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
34293 34293 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
34294 34294 esac
34295 34295 if test "x$ac_cv_prog_cc_c89" != xno; then :
34296 34296
34297 34297 fi
34298 34298
34299 34299 ac_ext=cpp
34300 34300 ac_cpp='$CXXCPP $CPPFLAGS'
34301 34301 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
34302 34302 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
34303 34303 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
34304 34304
34305 34305
34306 34306
34307 34307 COMPILER_NAME=C++
34308 34308 SEARCH_LIST="$TOOLCHAIN_CXX_BINARY"
34309 34309
34310 34310 if test "x$CXX" != x; then
34311 34311 # User has supplied compiler name already, always let that override.
34312 34312 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
34313 34313 $as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
34314 34314 if test "x`basename $CXX`" = "x$CXX"; then
34315 34315 # A command without a complete path is provided, search $PATH.
34316 34316
34317 34317 for ac_prog in $CXX
34318 34318 do
34319 34319 # Extract the first word of "$ac_prog", so it can be a program name with args.
34320 34320 set dummy $ac_prog; ac_word=$2
34321 34321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34322 34322 $as_echo_n "checking for $ac_word... " >&6; }
34323 34323 if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
34324 34324 $as_echo_n "(cached) " >&6
34325 34325 else
34326 34326 case $POTENTIAL_CXX in
34327 34327 [\\/]* | ?:[\\/]*)
34328 34328 ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
34329 34329 ;;
34330 34330 *)
34331 34331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34332 34332 for as_dir in $PATH
34333 34333 do
34334 34334 IFS=$as_save_IFS
34335 34335 test -z "$as_dir" && as_dir=.
34336 34336 for ac_exec_ext in '' $ac_executable_extensions; do
34337 34337 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34338 34338 ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
34339 34339 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34340 34340 break 2
34341 34341 fi
34342 34342 done
34343 34343 done
34344 34344 IFS=$as_save_IFS
34345 34345
34346 34346 ;;
34347 34347 esac
34348 34348 fi
34349 34349 POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
34350 34350 if test -n "$POTENTIAL_CXX"; then
34351 34351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
34352 34352 $as_echo "$POTENTIAL_CXX" >&6; }
34353 34353 else
34354 34354 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34355 34355 $as_echo "no" >&6; }
34356 34356 fi
34357 34357
34358 34358
34359 34359 test -n "$POTENTIAL_CXX" && break
34360 34360 done
34361 34361
34362 34362 if test "x$POTENTIAL_CXX" != x; then
34363 34363 CXX=$POTENTIAL_CXX
34364 34364 else
34365 34365 as_fn_error $? "User supplied compiler CXX=$CXX could not be found" "$LINENO" 5
34366 34366 fi
34367 34367 else
34368 34368 # Otherwise it might already be a complete path
34369 34369 if test ! -x "$CXX"; then
34370 34370 as_fn_error $? "User supplied compiler CXX=$CXX does not exist" "$LINENO" 5
34371 34371 fi
34372 34372 fi
34373 34373 else
34374 34374 # No user supplied value. Locate compiler ourselves.
34375 34375
34376 34376 # If we are cross compiling, assume cross compilation tools follows the
34377 34377 # cross compilation standard where they are prefixed with the autoconf
34378 34378 # standard name for the target. For example the binary
34379 34379 # i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
34380 34380 # If we are not cross compiling, then the default compiler name will be
34381 34381 # used.
34382 34382
34383 34383 CXX=
34384 34384 # If TOOLCHAIN_PATH is set, check for all compiler names in there first
34385 34385 # before checking the rest of the PATH.
34386 34386 # FIXME: Now that we prefix the TOOLS_DIR to the PATH in the PRE_DETECTION
34387 34387 # step, this should not be necessary.
34388 34388 if test -n "$TOOLCHAIN_PATH"; then
34389 34389 PATH_save="$PATH"
34390 34390 PATH="$TOOLCHAIN_PATH"
34391 34391 for ac_prog in $SEARCH_LIST
34392 34392 do
34393 34393 # Extract the first word of "$ac_prog", so it can be a program name with args.
34394 34394 set dummy $ac_prog; ac_word=$2
34395 34395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34396 34396 $as_echo_n "checking for $ac_word... " >&6; }
34397 34397 if ${ac_cv_path_TOOLCHAIN_PATH_CXX+:} false; then :
34398 34398 $as_echo_n "(cached) " >&6
34399 34399 else
34400 34400 case $TOOLCHAIN_PATH_CXX in
34401 34401 [\\/]* | ?:[\\/]*)
34402 34402 ac_cv_path_TOOLCHAIN_PATH_CXX="$TOOLCHAIN_PATH_CXX" # Let the user override the test with a path.
34403 34403 ;;
34404 34404 *)
34405 34405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34406 34406 for as_dir in $PATH
34407 34407 do
34408 34408 IFS=$as_save_IFS
34409 34409 test -z "$as_dir" && as_dir=.
34410 34410 for ac_exec_ext in '' $ac_executable_extensions; do
34411 34411 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34412 34412 ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir/$ac_word$ac_exec_ext"
34413 34413 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34414 34414 break 2
34415 34415 fi
34416 34416 done
34417 34417 done
34418 34418 IFS=$as_save_IFS
34419 34419
34420 34420 ;;
34421 34421 esac
34422 34422 fi
34423 34423 TOOLCHAIN_PATH_CXX=$ac_cv_path_TOOLCHAIN_PATH_CXX
34424 34424 if test -n "$TOOLCHAIN_PATH_CXX"; then
34425 34425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
34426 34426 $as_echo "$TOOLCHAIN_PATH_CXX" >&6; }
34427 34427 else
34428 34428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34429 34429 $as_echo "no" >&6; }
34430 34430 fi
34431 34431
34432 34432
34433 34433 test -n "$TOOLCHAIN_PATH_CXX" && break
34434 34434 done
34435 34435
34436 34436 CXX=$TOOLCHAIN_PATH_CXX
34437 34437 PATH="$PATH_save"
34438 34438 fi
34439 34439
34440 34440 # AC_PATH_PROGS can't be run multiple times with the same variable,
34441 34441 # so create a new name for this run.
34442 34442 if test "x$CXX" = x; then
34443 34443 for ac_prog in $SEARCH_LIST
34444 34444 do
34445 34445 # Extract the first word of "$ac_prog", so it can be a program name with args.
34446 34446 set dummy $ac_prog; ac_word=$2
34447 34447 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
34448 34448 $as_echo_n "checking for $ac_word... " >&6; }
34449 34449 if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
34450 34450 $as_echo_n "(cached) " >&6
34451 34451 else
34452 34452 case $POTENTIAL_CXX in
34453 34453 [\\/]* | ?:[\\/]*)
34454 34454 ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
34455 34455 ;;
34456 34456 *)
34457 34457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
34458 34458 for as_dir in $PATH
34459 34459 do
34460 34460 IFS=$as_save_IFS
34461 34461 test -z "$as_dir" && as_dir=.
34462 34462 for ac_exec_ext in '' $ac_executable_extensions; do
34463 34463 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
34464 34464 ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
34465 34465 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
34466 34466 break 2
34467 34467 fi
34468 34468 done
34469 34469 done
34470 34470 IFS=$as_save_IFS
34471 34471
34472 34472 ;;
34473 34473 esac
34474 34474 fi
34475 34475 POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
34476 34476 if test -n "$POTENTIAL_CXX"; then
34477 34477 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
34478 34478 $as_echo "$POTENTIAL_CXX" >&6; }
34479 34479 else
34480 34480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
34481 34481 $as_echo "no" >&6; }
34482 34482 fi
34483 34483
34484 34484
34485 34485 test -n "$POTENTIAL_CXX" && break
34486 34486 done
34487 34487
34488 34488 CXX=$POTENTIAL_CXX
34489 34489 fi
34490 34490
34491 34491 if test "x$CXX" = x; then
34492 34492
34493 34493 # Print a helpful message on how to acquire the necessary build dependency.
34494 34494 # devkit is the help tag: freetype, cups, alsa etc
34495 34495 MISSING_DEPENDENCY=devkit
34496 34496
34497 34497 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34498 34498 cygwin_help $MISSING_DEPENDENCY
34499 34499 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34500 34500 msys_help $MISSING_DEPENDENCY
34501 34501 else
34502 34502 PKGHANDLER_COMMAND=
34503 34503
34504 34504 case $PKGHANDLER in
34505 34505 apt-get)
34506 34506 apt_help $MISSING_DEPENDENCY ;;
34507 34507 yum)
34508 34508 yum_help $MISSING_DEPENDENCY ;;
34509 34509 port)
34510 34510 port_help $MISSING_DEPENDENCY ;;
34511 34511 pkgutil)
34512 34512 pkgutil_help $MISSING_DEPENDENCY ;;
34513 34513 pkgadd)
34514 34514 pkgadd_help $MISSING_DEPENDENCY ;;
34515 34515 esac
34516 34516
34517 34517 if test "x$PKGHANDLER_COMMAND" != x; then
34518 34518 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
34519 34519 fi
34520 34520 fi
34521 34521
34522 34522 as_fn_error $? "Could not find a $COMPILER_NAME compiler. $HELP_MSG" "$LINENO" 5
34523 34523 fi
34524 34524 fi
34525 34525
34526 34526 # Now we have a compiler binary in CXX. Make sure it's okay.
34527 34527
34528 34528 # Only process if variable expands to non-empty
34529 34529
34530 34530 if test "x$CXX" != x; then
34531 34531 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34532 34532
34533 34533 # First separate the path from the arguments. This will split at the first
34534 34534 # space.
34535 34535 complete="$CXX"
34536 34536 path="${complete%% *}"
34537 34537 tmp="$complete EOL"
34538 34538 arguments="${tmp#* }"
34539 34539
34540 34540 # Input might be given as Windows format, start by converting to
34541 34541 # unix format.
34542 34542 new_path=`$CYGPATH -u "$path"`
34543 34543
34544 34544 # Now try to locate executable using which
34545 34545 new_path=`$WHICH "$new_path" 2> /dev/null`
34546 34546 # bat and cmd files are not always considered executable in cygwin causing which
34547 34547 # to not find them
34548 34548 if test "x$new_path" = x \
34549 34549 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34550 34550 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34551 34551 new_path=`$CYGPATH -u "$path"`
34552 34552 fi
34553 34553 if test "x$new_path" = x; then
34554 34554 # Oops. Which didn't find the executable.
34555 34555 # The splitting of arguments from the executable at a space might have been incorrect,
34556 34556 # since paths with space are more likely in Windows. Give it another try with the whole
34557 34557 # argument.
34558 34558 path="$complete"
34559 34559 arguments="EOL"
34560 34560 new_path=`$CYGPATH -u "$path"`
34561 34561 new_path=`$WHICH "$new_path" 2> /dev/null`
34562 34562 # bat and cmd files are not always considered executable in cygwin causing which
34563 34563 # to not find them
34564 34564 if test "x$new_path" = x \
34565 34565 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34566 34566 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34567 34567 new_path=`$CYGPATH -u "$path"`
34568 34568 fi
34569 34569 if test "x$new_path" = x; then
34570 34570 # It's still not found. Now this is an unrecoverable error.
34571 34571 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
34572 34572 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
34573 34573 has_space=`$ECHO "$complete" | $GREP " "`
34574 34574 if test "x$has_space" != x; then
34575 34575 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34576 34576 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34577 34577 fi
34578 34578 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
34579 34579 fi
34580 34580 fi
34581 34581
34582 34582 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
34583 34583 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
34584 34584 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
34585 34585 # "foo.exe" is OK but "foo" is an error.
34586 34586 #
34587 34587 # This test is therefore slightly more accurate than "test -f" to check for file presence.
34588 34588 # It is also a way to make sure we got the proper file name for the real test later on.
34589 34589 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
34590 34590 if test "x$test_shortpath" = x; then
34591 34591 # Short path failed, file does not exist as specified.
34592 34592 # Try adding .exe or .cmd
34593 34593 if test -f "${new_path}.exe"; then
34594 34594 input_to_shortpath="${new_path}.exe"
34595 34595 elif test -f "${new_path}.cmd"; then
34596 34596 input_to_shortpath="${new_path}.cmd"
34597 34597 else
34598 34598 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
34599 34599 $as_echo "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
34600 34600 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
34601 34601 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
34602 34602 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
34603 34603 fi
34604 34604 else
34605 34605 input_to_shortpath="$new_path"
34606 34606 fi
34607 34607
34608 34608 # Call helper function which possibly converts this using DOS-style short mode.
34609 34609 # If so, the updated path is stored in $new_path.
34610 34610 new_path="$input_to_shortpath"
34611 34611
34612 34612 input_path="$input_to_shortpath"
34613 34613 # Check if we need to convert this using DOS-style short mode. If the path
34614 34614 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34615 34615 # take no chances and rewrite it.
34616 34616 # Note: m4 eats our [], so we need to use [ and ] instead.
34617 34617 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
34618 34618 if test "x$has_forbidden_chars" != x; then
34619 34619 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34620 34620 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
34621 34621 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
34622 34622 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
34623 34623 # Going to short mode and back again did indeed matter. Since short mode is
34624 34624 # case insensitive, let's make it lowercase to improve readability.
34625 34625 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34626 34626 # Now convert it back to Unix-style (cygpath)
34627 34627 input_path=`$CYGPATH -u "$shortmode_path"`
34628 34628 new_path="$input_path"
34629 34629 fi
34630 34630 fi
34631 34631
34632 34632 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
34633 34633 if test "x$test_cygdrive_prefix" = x; then
34634 34634 # As a simple fix, exclude /usr/bin since it's not a real path.
34635 34635 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
34636 34636 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
34637 34637 # a path prefixed by /cygdrive for fixpath to work.
34638 34638 new_path="$CYGWIN_ROOT_PATH$input_path"
34639 34639 fi
34640 34640 fi
34641 34641
34642 34642 # remove trailing .exe if any
34643 34643 new_path="${new_path/%.exe/}"
34644 34644
34645 34645 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34646 34646
34647 34647 # First separate the path from the arguments. This will split at the first
34648 34648 # space.
34649 34649 complete="$CXX"
34650 34650 path="${complete%% *}"
34651 34651 tmp="$complete EOL"
34652 34652 arguments="${tmp#* }"
34653 34653
34654 34654 # Input might be given as Windows format, start by converting to
34655 34655 # unix format.
34656 34656 new_path="$path"
34657 34657
34658 34658 windows_path="$new_path"
34659 34659 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34660 34660 unix_path=`$CYGPATH -u "$windows_path"`
34661 34661 new_path="$unix_path"
34662 34662 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34663 34663 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34664 34664 new_path="$unix_path"
34665 34665 fi
34666 34666
34667 34667
34668 34668 # Now try to locate executable using which
34669 34669 new_path=`$WHICH "$new_path" 2> /dev/null`
34670 34670
34671 34671 if test "x$new_path" = x; then
34672 34672 # Oops. Which didn't find the executable.
34673 34673 # The splitting of arguments from the executable at a space might have been incorrect,
34674 34674 # since paths with space are more likely in Windows. Give it another try with the whole
34675 34675 # argument.
34676 34676 path="$complete"
34677 34677 arguments="EOL"
34678 34678 new_path="$path"
34679 34679
34680 34680 windows_path="$new_path"
34681 34681 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34682 34682 unix_path=`$CYGPATH -u "$windows_path"`
34683 34683 new_path="$unix_path"
34684 34684 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34685 34685 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34686 34686 new_path="$unix_path"
34687 34687 fi
34688 34688
34689 34689
34690 34690 new_path=`$WHICH "$new_path" 2> /dev/null`
34691 34691 # bat and cmd files are not always considered executable in MSYS causing which
34692 34692 # to not find them
34693 34693 if test "x$new_path" = x \
34694 34694 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
34695 34695 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
34696 34696 new_path="$path"
34697 34697
34698 34698 windows_path="$new_path"
34699 34699 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34700 34700 unix_path=`$CYGPATH -u "$windows_path"`
34701 34701 new_path="$unix_path"
34702 34702 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34703 34703 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34704 34704 new_path="$unix_path"
34705 34705 fi
34706 34706
34707 34707 fi
34708 34708
34709 34709 if test "x$new_path" = x; then
34710 34710 # It's still not found. Now this is an unrecoverable error.
34711 34711 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
34712 34712 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
34713 34713 has_space=`$ECHO "$complete" | $GREP " "`
34714 34714 if test "x$has_space" != x; then
34715 34715 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
34716 34716 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
34717 34717 fi
34718 34718 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
34719 34719 fi
34720 34720 fi
34721 34721
34722 34722 # Now new_path has a complete unix path to the binary
34723 34723 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
34724 34724 # Keep paths in /bin as-is, but remove trailing .exe if any
34725 34725 new_path="${new_path/%.exe/}"
34726 34726 # Do not save /bin paths to all_fixpath_prefixes!
34727 34727 else
34728 34728 # Not in mixed or Windows style, start by that.
34729 34729 new_path=`cmd //c echo $new_path`
34730 34730
34731 34731 input_path="$new_path"
34732 34732 # Check if we need to convert this using DOS-style short mode. If the path
34733 34733 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34734 34734 # take no chances and rewrite it.
34735 34735 # Note: m4 eats our [], so we need to use [ and ] instead.
34736 34736 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
34737 34737 if test "x$has_forbidden_chars" != x; then
34738 34738 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34739 34739 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34740 34740 fi
34741 34741
34742 34742 # Output is in $new_path
34743 34743
34744 34744 windows_path="$new_path"
34745 34745 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34746 34746 unix_path=`$CYGPATH -u "$windows_path"`
34747 34747 new_path="$unix_path"
34748 34748 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34749 34749 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34750 34750 new_path="$unix_path"
34751 34751 fi
34752 34752
34753 34753 # remove trailing .exe if any
34754 34754 new_path="${new_path/%.exe/}"
34755 34755
34756 34756 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34757 34757 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34758 34758 fi
34759 34759
34760 34760 else
34761 34761 # We're on a unix platform. Hooray! :)
34762 34762 # First separate the path from the arguments. This will split at the first
34763 34763 # space.
34764 34764 complete="$CXX"
34765 34765 path="${complete%% *}"
34766 34766 tmp="$complete EOL"
34767 34767 arguments="${tmp#* }"
34768 34768
34769 34769 # Cannot rely on the command "which" here since it doesn't always work.
34770 34770 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34771 34771 if test -z "$is_absolute_path"; then
34772 34772 # Path to executable is not absolute. Find it.
34773 34773 IFS_save="$IFS"
34774 34774 IFS=:
34775 34775 for p in $PATH; do
34776 34776 if test -f "$p/$path" && test -x "$p/$path"; then
34777 34777 new_path="$p/$path"
34778 34778 break
34779 34779 fi
34780 34780 done
34781 34781 IFS="$IFS_save"
34782 34782 else
34783 34783 # This is an absolute path, we can use it without further modifications.
34784 34784 new_path="$path"
34785 34785 fi
34786 34786
34787 34787 if test "x$new_path" = x; then
34788 34788 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
34789 34789 $as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
34790 34790 has_space=`$ECHO "$complete" | $GREP " "`
34791 34791 if test "x$has_space" != x; then
34792 34792 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
34793 34793 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
34794 34794 fi
34795 34795 as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
34796 34796 fi
34797 34797 fi
34798 34798
34799 34799 # Now join together the path and the arguments once again
34800 34800 if test "x$arguments" != xEOL; then
34801 34801 new_complete="$new_path ${arguments% *}"
34802 34802 else
34803 34803 new_complete="$new_path"
34804 34804 fi
34805 34805
34806 34806 if test "x$complete" != "x$new_complete"; then
34807 34807 CXX="$new_complete"
34808 34808 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
34809 34809 $as_echo "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
34810 34810 fi
34811 34811 fi
34812 34812
34813 34813 TEST_COMPILER="$CXX"
34814 34814
34815 34815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
34816 34816 $as_echo_n "checking resolved symbolic links for CXX... " >&6; }
34817 34817 SYMLINK_ORIGINAL="$TEST_COMPILER"
34818 34818
34819 34819 if test "x$OPENJDK_BUILD_OS" != xwindows; then
34820 34820 # Follow a chain of symbolic links. Use readlink
34821 34821 # where it exists, else fall back to horribly
34822 34822 # complicated shell code.
34823 34823 if test "x$READLINK_TESTED" != yes; then
34824 34824 # On MacOSX there is a readlink tool with a different
34825 34825 # purpose than the GNU readlink tool. Check the found readlink.
34826 34826 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
34827 34827 if test "x$ISGNU" = x; then
34828 34828 # A readlink that we do not know how to use.
34829 34829 # Are there other non-GNU readlinks out there?
34830 34830 READLINK_TESTED=yes
34831 34831 READLINK=
34832 34832 fi
34833 34833 fi
34834 34834
34835 34835 if test "x$READLINK" != x; then
34836 34836 SYMLINK_ORIGINAL=`$READLINK -f $SYMLINK_ORIGINAL`
34837 34837 else
34838 34838 # Save the current directory for restoring afterwards
34839 34839 STARTDIR=$PWD
34840 34840 COUNTER=0
34841 34841 sym_link_dir=`$DIRNAME $SYMLINK_ORIGINAL`
34842 34842 sym_link_file=`$BASENAME $SYMLINK_ORIGINAL`
34843 34843 cd $sym_link_dir
34844 34844 # Use -P flag to resolve symlinks in directories.
34845 34845 cd `$THEPWDCMD -P`
34846 34846 sym_link_dir=`$THEPWDCMD -P`
34847 34847 # Resolve file symlinks
34848 34848 while test $COUNTER -lt 20; do
34849 34849 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
34850 34850 if test "x$ISLINK" == x; then
34851 34851 # This is not a symbolic link! We are done!
34852 34852 break
34853 34853 fi
34854 34854 # Again resolve directory symlinks since the target of the just found
34855 34855 # link could be in a different directory
34856 34856 cd `$DIRNAME $ISLINK`
34857 34857 sym_link_dir=`$THEPWDCMD -P`
34858 34858 sym_link_file=`$BASENAME $ISLINK`
34859 34859 let COUNTER=COUNTER+1
34860 34860 done
34861 34861 cd $STARTDIR
34862 34862 SYMLINK_ORIGINAL=$sym_link_dir/$sym_link_file
34863 34863 fi
34864 34864 fi
34865 34865
34866 34866 if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
34867 34867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
34868 34868 $as_echo "no symlink" >&6; }
34869 34869 else
34870 34870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
34871 34871 $as_echo "$SYMLINK_ORIGINAL" >&6; }
34872 34872
34873 34873 # We can't handle ccache by gcc wrappers, since we need to know if we're
34874 34874 # using ccache. Instead ccache usage must be controlled by a configure option.
34875 34875 COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
34876 34876 if test "x$COMPILER_BASENAME" = "xccache"; then
34877 34877 { $as_echo "$as_me:${as_lineno-$LINENO}: Please use --enable-ccache instead of providing a wrapped compiler." >&5
34878 34878 $as_echo "$as_me: Please use --enable-ccache instead of providing a wrapped compiler." >&6;}
34879 34879 as_fn_error $? "$TEST_COMPILER is a symbolic link to ccache. This is not supported." "$LINENO" 5
34880 34880 fi
34881 34881 fi
34882 34882
34883 34883
34884 34884 COMPILER=$CXX
34885 34885 COMPILER_NAME=$COMPILER_NAME
34886 34886
34887 34887 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
34888 34888 # cc -V output typically looks like
34889 34889 # cc: Sun C 5.12 Linux_i386 2011/11/16
34890 34890 COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
34891 34891 # Check that this is likely to be the Solaris Studio cc.
34892 34892 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
34893 34893 if test $? -ne 0; then
34894 34894 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
34895 34895 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
34896 34896 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
34897 34897 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
34898 34898 $as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
34899 34899 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
34900 34900 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
34901 34901 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
34902 34902 fi
34903 34903 # Remove usage instructions (if present), and
34904 34904 # collapse compiler output into a single line
34905 34905 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
34906 34906 $SED -e 's/ *[Uu]sage:.*//'`
34907 34907 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
34908 34908 $SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
34909 34909 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
34910 34910 # xlc -qversion output typically looks like
34911 34911 # IBM XL C/C++ for AIX, V11.1 (5724-X13)
34912 34912 # Version: 11.01.0000.0015
34913 34913 COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
34914 34914 # Check that this is likely to be the IBM XL C compiler.
34915 34915 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
34916 34916 if test $? -ne 0; then
34917 34917 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
34918 34918 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
34919 34919 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
34920 34920 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
34921 34921 $as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
34922 34922 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
34923 34923 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
34924 34924 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
34925 34925 fi
34926 34926 # Collapse compiler output into a single line
34927 34927 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
34928 34928 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
34929 34929 $SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
34930 34930 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
34931 34931 # There is no specific version flag, but all output starts with a version string.
34932 34932 # First line typically looks something like:
34933 34933 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
34934 34934 COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
34935 34935 # Check that this is likely to be Microsoft CL.EXE.
34936 34936 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
34937 34937 if test $? -ne 0; then
34938 34938 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
34939 34939 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
34940 34940 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
34941 34941 $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
34942 34942 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
34943 34943 fi
34944 34944 # Collapse compiler output into a single line
34945 34945 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
34946 34946 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
34947 34947 $SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
34948 34948 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
34949 34949 # gcc --version output typically looks like
34950 34950 # gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
34951 34951 # Copyright (C) 2013 Free Software Foundation, Inc.
34952 34952 # This is free software; see the source for copying conditions. There is NO
34953 34953 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
34954 34954 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
34955 34955 # Check that this is likely to be GCC.
34956 34956 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
34957 34957 if test $? -ne 0; then
34958 34958 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
34959 34959 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
34960 34960 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
34961 34961 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
34962 34962 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
34963 34963 fi
34964 34964 # Remove Copyright and legalese from version string, and
34965 34965 # collapse into a single line
34966 34966 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
34967 34967 $SED -e 's/ *Copyright .*//'`
34968 34968 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
34969 34969 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
34970 34970 elif test "x$TOOLCHAIN_TYPE" = xclang; then
34971 34971 # clang --version output typically looks like
34972 34972 # Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
34973 34973 # clang version 3.3 (tags/RELEASE_33/final)
34974 34974 # or
34975 34975 # Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
34976 34976 # Target: x86_64-pc-linux-gnu
34977 34977 # Thread model: posix
34978 34978 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
34979 34979 # Check that this is likely to be clang
34980 34980 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
34981 34981 if test $? -ne 0; then
34982 34982 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
34983 34983 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
34984 34984 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
34985 34985 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
34986 34986 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
34987 34987 fi
34988 34988 # Collapse compiler output into a single line
34989 34989 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
34990 34990 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
34991 34991 $SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
34992 34992 else
34993 34993 as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
34994 34994 fi
34995 34995 # This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
34996 34996 CXX_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
34997 34997 # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
34998 34998 CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
34999 34999
35000 35000 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
35001 35001 $as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
35002 35002
35003 35003
35004 35004 # Now that we have resolved CXX ourself, let autoconf have its go at it
35005 35005 ac_ext=cpp
35006 35006 ac_cpp='$CXXCPP $CPPFLAGS'
35007 35007 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35008 35008 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35009 35009 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
35010 35010 if test -z "$CXX"; then
35011 35011 if test -n "$CCC"; then
35012 35012 CXX=$CCC
35013 35013 else
35014 35014 if test -n "$ac_tool_prefix"; then
35015 35015 for ac_prog in $CXX
35016 35016 do
35017 35017 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
35018 35018 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
35019 35019 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35020 35020 $as_echo_n "checking for $ac_word... " >&6; }
35021 35021 if ${ac_cv_prog_CXX+:} false; then :
35022 35022 $as_echo_n "(cached) " >&6
35023 35023 else
35024 35024 if test -n "$CXX"; then
35025 35025 ac_cv_prog_CXX="$CXX" # Let the user override the test.
35026 35026 else
35027 35027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35028 35028 for as_dir in $PATH
35029 35029 do
35030 35030 IFS=$as_save_IFS
35031 35031 test -z "$as_dir" && as_dir=.
35032 35032 for ac_exec_ext in '' $ac_executable_extensions; do
35033 35033 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35034 35034 ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
35035 35035 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35036 35036 break 2
35037 35037 fi
35038 35038 done
35039 35039 done
35040 35040 IFS=$as_save_IFS
35041 35041
35042 35042 fi
35043 35043 fi
35044 35044 CXX=$ac_cv_prog_CXX
35045 35045 if test -n "$CXX"; then
35046 35046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
35047 35047 $as_echo "$CXX" >&6; }
35048 35048 else
35049 35049 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35050 35050 $as_echo "no" >&6; }
35051 35051 fi
35052 35052
35053 35053
35054 35054 test -n "$CXX" && break
35055 35055 done
35056 35056 fi
35057 35057 if test -z "$CXX"; then
35058 35058 ac_ct_CXX=$CXX
35059 35059 for ac_prog in $CXX
35060 35060 do
35061 35061 # Extract the first word of "$ac_prog", so it can be a program name with args.
35062 35062 set dummy $ac_prog; ac_word=$2
35063 35063 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
35064 35064 $as_echo_n "checking for $ac_word... " >&6; }
35065 35065 if ${ac_cv_prog_ac_ct_CXX+:} false; then :
35066 35066 $as_echo_n "(cached) " >&6
35067 35067 else
35068 35068 if test -n "$ac_ct_CXX"; then
35069 35069 ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
35070 35070 else
35071 35071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
35072 35072 for as_dir in $PATH
35073 35073 do
35074 35074 IFS=$as_save_IFS
35075 35075 test -z "$as_dir" && as_dir=.
35076 35076 for ac_exec_ext in '' $ac_executable_extensions; do
35077 35077 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
35078 35078 ac_cv_prog_ac_ct_CXX="$ac_prog"
35079 35079 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
35080 35080 break 2
35081 35081 fi
35082 35082 done
35083 35083 done
35084 35084 IFS=$as_save_IFS
35085 35085
35086 35086 fi
35087 35087 fi
35088 35088 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
35089 35089 if test -n "$ac_ct_CXX"; then
35090 35090 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
35091 35091 $as_echo "$ac_ct_CXX" >&6; }
35092 35092 else
35093 35093 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
35094 35094 $as_echo "no" >&6; }
35095 35095 fi
35096 35096
35097 35097
35098 35098 test -n "$ac_ct_CXX" && break
35099 35099 done
35100 35100
35101 35101 if test "x$ac_ct_CXX" = x; then
35102 35102 CXX="g++"
35103 35103 else
35104 35104 case $cross_compiling:$ac_tool_warned in
35105 35105 yes:)
35106 35106 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
35107 35107 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
35108 35108 ac_tool_warned=yes ;;
35109 35109 esac
35110 35110 CXX=$ac_ct_CXX
35111 35111 fi
35112 35112 fi
35113 35113
35114 35114 fi
35115 35115 fi
35116 35116 # Provide some information about the compiler.
35117 35117 $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
35118 35118 set X $ac_compile
35119 35119 ac_compiler=$2
35120 35120 for ac_option in --version -v -V -qversion; do
35121 35121 { { ac_try="$ac_compiler $ac_option >&5"
35122 35122 case "(($ac_try" in
35123 35123 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
35124 35124 *) ac_try_echo=$ac_try;;
35125 35125 esac
35126 35126 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
35127 35127 $as_echo "$ac_try_echo"; } >&5
35128 35128 (eval "$ac_compiler $ac_option >&5") 2>conftest.err
35129 35129 ac_status=$?
35130 35130 if test -s conftest.err; then
35131 35131 sed '10a\
35132 35132 ... rest of stderr output deleted ...
35133 35133 10q' conftest.err >conftest.er1
35134 35134 cat conftest.er1 >&5
35135 35135 fi
35136 35136 rm -f conftest.er1 conftest.err
35137 35137 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
35138 35138 test $ac_status = 0; }
35139 35139 done
35140 35140
35141 35141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
35142 35142 $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
35143 35143 if ${ac_cv_cxx_compiler_gnu+:} false; then :
35144 35144 $as_echo_n "(cached) " >&6
35145 35145 else
35146 35146 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35147 35147 /* end confdefs.h. */
35148 35148
35149 35149 int
35150 35150 main ()
35151 35151 {
35152 35152 #ifndef __GNUC__
35153 35153 choke me
35154 35154 #endif
35155 35155
35156 35156 ;
35157 35157 return 0;
35158 35158 }
35159 35159 _ACEOF
35160 35160 if ac_fn_cxx_try_compile "$LINENO"; then :
35161 35161 ac_compiler_gnu=yes
35162 35162 else
35163 35163 ac_compiler_gnu=no
35164 35164 fi
35165 35165 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
35166 35166 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
35167 35167
35168 35168 fi
35169 35169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
35170 35170 $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
35171 35171 if test $ac_compiler_gnu = yes; then
35172 35172 GXX=yes
35173 35173 else
35174 35174 GXX=
35175 35175 fi
35176 35176 ac_test_CXXFLAGS=${CXXFLAGS+set}
35177 35177 ac_save_CXXFLAGS=$CXXFLAGS
35178 35178 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
35179 35179 $as_echo_n "checking whether $CXX accepts -g... " >&6; }
35180 35180 if ${ac_cv_prog_cxx_g+:} false; then :
35181 35181 $as_echo_n "(cached) " >&6
35182 35182 else
35183 35183 ac_save_cxx_werror_flag=$ac_cxx_werror_flag
35184 35184 ac_cxx_werror_flag=yes
35185 35185 ac_cv_prog_cxx_g=no
35186 35186 CXXFLAGS="-g"
35187 35187 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35188 35188 /* end confdefs.h. */
35189 35189
35190 35190 int
35191 35191 main ()
35192 35192 {
35193 35193
35194 35194 ;
35195 35195 return 0;
35196 35196 }
35197 35197 _ACEOF
35198 35198 if ac_fn_cxx_try_compile "$LINENO"; then :
35199 35199 ac_cv_prog_cxx_g=yes
35200 35200 else
35201 35201 CXXFLAGS=""
35202 35202 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35203 35203 /* end confdefs.h. */
35204 35204
35205 35205 int
35206 35206 main ()
35207 35207 {
35208 35208
35209 35209 ;
35210 35210 return 0;
35211 35211 }
35212 35212 _ACEOF
35213 35213 if ac_fn_cxx_try_compile "$LINENO"; then :
35214 35214
35215 35215 else
35216 35216 ac_cxx_werror_flag=$ac_save_cxx_werror_flag
35217 35217 CXXFLAGS="-g"
35218 35218 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35219 35219 /* end confdefs.h. */
35220 35220
35221 35221 int
35222 35222 main ()
35223 35223 {
35224 35224
35225 35225 ;
35226 35226 return 0;
35227 35227 }
35228 35228 _ACEOF
35229 35229 if ac_fn_cxx_try_compile "$LINENO"; then :
35230 35230 ac_cv_prog_cxx_g=yes
35231 35231 fi
35232 35232 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
35233 35233 fi
35234 35234 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
35235 35235 fi
35236 35236 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
35237 35237 ac_cxx_werror_flag=$ac_save_cxx_werror_flag
35238 35238 fi
35239 35239 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
35240 35240 $as_echo "$ac_cv_prog_cxx_g" >&6; }
35241 35241 if test "$ac_test_CXXFLAGS" = set; then
35242 35242 CXXFLAGS=$ac_save_CXXFLAGS
35243 35243 elif test $ac_cv_prog_cxx_g = yes; then
35244 35244 if test "$GXX" = yes; then
35245 35245 CXXFLAGS="-g -O2"
35246 35246 else
35247 35247 CXXFLAGS="-g"
35248 35248 fi
35249 35249 else
35250 35250 if test "$GXX" = yes; then
35251 35251 CXXFLAGS="-O2"
35252 35252 else
35253 35253 CXXFLAGS=
35254 35254 fi
35255 35255 fi
35256 35256 ac_ext=cpp
35257 35257 ac_cpp='$CXXCPP $CPPFLAGS'
35258 35258 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35259 35259 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35260 35260 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
35261 35261
35262 35262
35263 35263 # This is the compiler version number on the form X.Y[.Z]
35264 35264
35265 35265
35266 35266
35267 35267
35268 35268 if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
35269 35269 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
35270 35270 $as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
35271 35271 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
35272 35272 $as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
35273 35273 fi
35274 35274
35275 35275 # We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
35276 35276 if [[ "[$]CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
35277 35277 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
35278 35278 $as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
35279 35279 fi
35280 35280
35281 35281 if [[ "[$]CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
35282 35282 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
35283 35283 $as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
35284 35284 fi
35285 35285
35286 35286 COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$CC_VERSION_NUMBER"`
35287 35287
35288 35288
35289 35289 if test "x$TOOLCHAIN_MINIMUM_VERSION" != x; then
35290 35290
35291 35291
35292 35292
35293 35293
35294 35294
35295 35295
35296 35296
35297 35297
35298 35298
35299 35299
35300 35300
35301 35301
35302 35302
35303 35303
35304 35304
35305 35305
35306 35306
35307 35307
35308 35308
35309 35309
35310 35310
35311 35311
35312 35312
35313 35313
35314 35314
35315 35315
35316 35316
35317 35317
35318 35318
35319 35319
35320 35320
35321 35321
35322 35322
35323 35323
35324 35324
35325 35325
35326 35326
35327 35327
35328 35328
35329 35329
35330 35330
35331 35331
35332 35332
35333 35333
35334 35334
35335 35335
35336 35336
35337 35337
35338 35338
35339 35339 # Execute function body
35340 35340
35341 35341 # Need to assign to a variable since m4 is blocked from modifying parts in [].
35342 35342 REFERENCE_VERSION=$TOOLCHAIN_MINIMUM_VERSION
35343 35343
35344 35344 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
35345 35345 as_fn_error $? "Internal error: Cannot compare to $TOOLCHAIN_MINIMUM_VERSION, only three parts (X.Y.Z) is supported" "$LINENO" 5
35346 35346 fi
35347 35347
35348 35348 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
35349 35349 as_fn_error $? "Internal error: Cannot compare to $TOOLCHAIN_MINIMUM_VERSION, only parts < 99999 is supported" "$LINENO" 5
35350 35350 fi
35351 35351
35352 35352 # Version comparison method inspired by http://stackoverflow.com/a/24067243
35353 35353 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
35354 35354
35355 35355 if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
35356 35356 :
35357 35357
35358 35358 else
35359 35359 :
35360 35360
35361 35361 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You are using $TOOLCHAIN_TYPE older than $TOOLCHAIN_MINIMUM_VERSION. This is not a supported configuration." >&5
35362 35362 $as_echo "$as_me: WARNING: You are using $TOOLCHAIN_TYPE older than $TOOLCHAIN_MINIMUM_VERSION. This is not a supported configuration." >&2;}
35363 35363
35364 35364
35365 35365 fi
35366 35366
35367 35367
35368 35368
35369 35369
35370 35370
35371 35371
35372 35372
35373 35373
35374 35374
35375 35375
35376 35376
35377 35377
35378 35378
35379 35379
35380 35380 fi
35381 35381
35382 35382 #
35383 35383 # Setup the preprocessor (CPP and CXXCPP)
35384 35384 #
35385 35385 ac_ext=c
35386 35386 ac_cpp='$CPP $CPPFLAGS'
35387 35387 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35388 35388 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35389 35389 ac_compiler_gnu=$ac_cv_c_compiler_gnu
35390 35390 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
35391 35391 $as_echo_n "checking how to run the C preprocessor... " >&6; }
35392 35392 # On Suns, sometimes $CPP names a directory.
35393 35393 if test -n "$CPP" && test -d "$CPP"; then
35394 35394 CPP=
35395 35395 fi
35396 35396 if test -z "$CPP"; then
35397 35397 if ${ac_cv_prog_CPP+:} false; then :
35398 35398 $as_echo_n "(cached) " >&6
35399 35399 else
35400 35400 # Double quotes because CPP needs to be expanded
35401 35401 for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
35402 35402 do
35403 35403 ac_preproc_ok=false
35404 35404 for ac_c_preproc_warn_flag in '' yes
35405 35405 do
35406 35406 # Use a header file that comes with gcc, so configuring glibc
35407 35407 # with a fresh cross-compiler works.
35408 35408 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
35409 35409 # <limits.h> exists even on freestanding compilers.
35410 35410 # On the NeXT, cc -E runs the code through the compiler's parser,
35411 35411 # not just through cpp. "Syntax error" is here to catch this case.
35412 35412 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35413 35413 /* end confdefs.h. */
35414 35414 #ifdef __STDC__
35415 35415 # include <limits.h>
35416 35416 #else
35417 35417 # include <assert.h>
35418 35418 #endif
35419 35419 Syntax error
35420 35420 _ACEOF
35421 35421 if ac_fn_c_try_cpp "$LINENO"; then :
35422 35422
35423 35423 else
35424 35424 # Broken: fails on valid input.
35425 35425 continue
35426 35426 fi
35427 35427 rm -f conftest.err conftest.i conftest.$ac_ext
35428 35428
35429 35429 # OK, works on sane cases. Now check whether nonexistent headers
35430 35430 # can be detected and how.
35431 35431 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35432 35432 /* end confdefs.h. */
35433 35433 #include <ac_nonexistent.h>
35434 35434 _ACEOF
35435 35435 if ac_fn_c_try_cpp "$LINENO"; then :
35436 35436 # Broken: success on invalid input.
35437 35437 continue
35438 35438 else
35439 35439 # Passes both tests.
35440 35440 ac_preproc_ok=:
35441 35441 break
35442 35442 fi
35443 35443 rm -f conftest.err conftest.i conftest.$ac_ext
35444 35444
35445 35445 done
35446 35446 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
35447 35447 rm -f conftest.i conftest.err conftest.$ac_ext
35448 35448 if $ac_preproc_ok; then :
35449 35449 break
35450 35450 fi
35451 35451
35452 35452 done
35453 35453 ac_cv_prog_CPP=$CPP
35454 35454
35455 35455 fi
35456 35456 CPP=$ac_cv_prog_CPP
35457 35457 else
35458 35458 ac_cv_prog_CPP=$CPP
35459 35459 fi
35460 35460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
35461 35461 $as_echo "$CPP" >&6; }
35462 35462 ac_preproc_ok=false
35463 35463 for ac_c_preproc_warn_flag in '' yes
35464 35464 do
35465 35465 # Use a header file that comes with gcc, so configuring glibc
35466 35466 # with a fresh cross-compiler works.
35467 35467 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
35468 35468 # <limits.h> exists even on freestanding compilers.
35469 35469 # On the NeXT, cc -E runs the code through the compiler's parser,
35470 35470 # not just through cpp. "Syntax error" is here to catch this case.
35471 35471 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35472 35472 /* end confdefs.h. */
35473 35473 #ifdef __STDC__
35474 35474 # include <limits.h>
35475 35475 #else
35476 35476 # include <assert.h>
35477 35477 #endif
35478 35478 Syntax error
35479 35479 _ACEOF
35480 35480 if ac_fn_c_try_cpp "$LINENO"; then :
35481 35481
35482 35482 else
35483 35483 # Broken: fails on valid input.
35484 35484 continue
35485 35485 fi
35486 35486 rm -f conftest.err conftest.i conftest.$ac_ext
35487 35487
35488 35488 # OK, works on sane cases. Now check whether nonexistent headers
35489 35489 # can be detected and how.
35490 35490 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35491 35491 /* end confdefs.h. */
35492 35492 #include <ac_nonexistent.h>
35493 35493 _ACEOF
35494 35494 if ac_fn_c_try_cpp "$LINENO"; then :
35495 35495 # Broken: success on invalid input.
35496 35496 continue
35497 35497 else
35498 35498 # Passes both tests.
35499 35499 ac_preproc_ok=:
35500 35500 break
35501 35501 fi
35502 35502 rm -f conftest.err conftest.i conftest.$ac_ext
35503 35503
35504 35504 done
35505 35505 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
35506 35506 rm -f conftest.i conftest.err conftest.$ac_ext
35507 35507 if $ac_preproc_ok; then :
35508 35508
35509 35509 else
35510 35510 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
35511 35511 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
35512 35512 as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
35513 35513 See \`config.log' for more details" "$LINENO" 5; }
35514 35514 fi
35515 35515
35516 35516 ac_ext=cpp
35517 35517 ac_cpp='$CXXCPP $CPPFLAGS'
35518 35518 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35519 35519 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35520 35520 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
35521 35521
35522 35522
35523 35523 # Only process if variable expands to non-empty
35524 35524
35525 35525 if test "x$CPP" != x; then
35526 35526 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35527 35527
35528 35528 # First separate the path from the arguments. This will split at the first
35529 35529 # space.
35530 35530 complete="$CPP"
35531 35531 path="${complete%% *}"
35532 35532 tmp="$complete EOL"
35533 35533 arguments="${tmp#* }"
35534 35534
35535 35535 # Input might be given as Windows format, start by converting to
35536 35536 # unix format.
35537 35537 new_path=`$CYGPATH -u "$path"`
35538 35538
35539 35539 # Now try to locate executable using which
35540 35540 new_path=`$WHICH "$new_path" 2> /dev/null`
35541 35541 # bat and cmd files are not always considered executable in cygwin causing which
35542 35542 # to not find them
35543 35543 if test "x$new_path" = x \
35544 35544 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35545 35545 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35546 35546 new_path=`$CYGPATH -u "$path"`
35547 35547 fi
35548 35548 if test "x$new_path" = x; then
35549 35549 # Oops. Which didn't find the executable.
35550 35550 # The splitting of arguments from the executable at a space might have been incorrect,
35551 35551 # since paths with space are more likely in Windows. Give it another try with the whole
35552 35552 # argument.
35553 35553 path="$complete"
35554 35554 arguments="EOL"
35555 35555 new_path=`$CYGPATH -u "$path"`
35556 35556 new_path=`$WHICH "$new_path" 2> /dev/null`
35557 35557 # bat and cmd files are not always considered executable in cygwin causing which
35558 35558 # to not find them
35559 35559 if test "x$new_path" = x \
35560 35560 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35561 35561 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35562 35562 new_path=`$CYGPATH -u "$path"`
35563 35563 fi
35564 35564 if test "x$new_path" = x; then
35565 35565 # It's still not found. Now this is an unrecoverable error.
35566 35566 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
35567 35567 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
35568 35568 has_space=`$ECHO "$complete" | $GREP " "`
35569 35569 if test "x$has_space" != x; then
35570 35570 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35571 35571 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35572 35572 fi
35573 35573 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
35574 35574 fi
35575 35575 fi
35576 35576
35577 35577 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
35578 35578 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
35579 35579 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
35580 35580 # "foo.exe" is OK but "foo" is an error.
35581 35581 #
35582 35582 # This test is therefore slightly more accurate than "test -f" to check for file presence.
35583 35583 # It is also a way to make sure we got the proper file name for the real test later on.
35584 35584 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
35585 35585 if test "x$test_shortpath" = x; then
35586 35586 # Short path failed, file does not exist as specified.
35587 35587 # Try adding .exe or .cmd
35588 35588 if test -f "${new_path}.exe"; then
35589 35589 input_to_shortpath="${new_path}.exe"
35590 35590 elif test -f "${new_path}.cmd"; then
35591 35591 input_to_shortpath="${new_path}.cmd"
35592 35592 else
35593 35593 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
35594 35594 $as_echo "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
35595 35595 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
35596 35596 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
35597 35597 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
35598 35598 fi
35599 35599 else
35600 35600 input_to_shortpath="$new_path"
35601 35601 fi
35602 35602
35603 35603 # Call helper function which possibly converts this using DOS-style short mode.
35604 35604 # If so, the updated path is stored in $new_path.
35605 35605 new_path="$input_to_shortpath"
35606 35606
35607 35607 input_path="$input_to_shortpath"
35608 35608 # Check if we need to convert this using DOS-style short mode. If the path
35609 35609 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35610 35610 # take no chances and rewrite it.
35611 35611 # Note: m4 eats our [], so we need to use [ and ] instead.
35612 35612 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
35613 35613 if test "x$has_forbidden_chars" != x; then
35614 35614 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35615 35615 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
35616 35616 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
35617 35617 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
35618 35618 # Going to short mode and back again did indeed matter. Since short mode is
35619 35619 # case insensitive, let's make it lowercase to improve readability.
35620 35620 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35621 35621 # Now convert it back to Unix-style (cygpath)
35622 35622 input_path=`$CYGPATH -u "$shortmode_path"`
35623 35623 new_path="$input_path"
35624 35624 fi
35625 35625 fi
35626 35626
35627 35627 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
35628 35628 if test "x$test_cygdrive_prefix" = x; then
35629 35629 # As a simple fix, exclude /usr/bin since it's not a real path.
35630 35630 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
35631 35631 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
35632 35632 # a path prefixed by /cygdrive for fixpath to work.
35633 35633 new_path="$CYGWIN_ROOT_PATH$input_path"
35634 35634 fi
35635 35635 fi
35636 35636
35637 35637 # remove trailing .exe if any
35638 35638 new_path="${new_path/%.exe/}"
35639 35639
35640 35640 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35641 35641
35642 35642 # First separate the path from the arguments. This will split at the first
35643 35643 # space.
35644 35644 complete="$CPP"
35645 35645 path="${complete%% *}"
35646 35646 tmp="$complete EOL"
35647 35647 arguments="${tmp#* }"
35648 35648
35649 35649 # Input might be given as Windows format, start by converting to
35650 35650 # unix format.
35651 35651 new_path="$path"
35652 35652
35653 35653 windows_path="$new_path"
35654 35654 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35655 35655 unix_path=`$CYGPATH -u "$windows_path"`
35656 35656 new_path="$unix_path"
35657 35657 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35658 35658 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35659 35659 new_path="$unix_path"
35660 35660 fi
35661 35661
35662 35662
35663 35663 # Now try to locate executable using which
35664 35664 new_path=`$WHICH "$new_path" 2> /dev/null`
35665 35665
35666 35666 if test "x$new_path" = x; then
35667 35667 # Oops. Which didn't find the executable.
35668 35668 # The splitting of arguments from the executable at a space might have been incorrect,
35669 35669 # since paths with space are more likely in Windows. Give it another try with the whole
35670 35670 # argument.
35671 35671 path="$complete"
35672 35672 arguments="EOL"
35673 35673 new_path="$path"
35674 35674
35675 35675 windows_path="$new_path"
35676 35676 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35677 35677 unix_path=`$CYGPATH -u "$windows_path"`
35678 35678 new_path="$unix_path"
35679 35679 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35680 35680 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35681 35681 new_path="$unix_path"
35682 35682 fi
35683 35683
35684 35684
35685 35685 new_path=`$WHICH "$new_path" 2> /dev/null`
35686 35686 # bat and cmd files are not always considered executable in MSYS causing which
35687 35687 # to not find them
35688 35688 if test "x$new_path" = x \
35689 35689 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35690 35690 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35691 35691 new_path="$path"
35692 35692
35693 35693 windows_path="$new_path"
35694 35694 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35695 35695 unix_path=`$CYGPATH -u "$windows_path"`
35696 35696 new_path="$unix_path"
35697 35697 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35698 35698 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35699 35699 new_path="$unix_path"
35700 35700 fi
35701 35701
35702 35702 fi
35703 35703
35704 35704 if test "x$new_path" = x; then
35705 35705 # It's still not found. Now this is an unrecoverable error.
35706 35706 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
35707 35707 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
35708 35708 has_space=`$ECHO "$complete" | $GREP " "`
35709 35709 if test "x$has_space" != x; then
35710 35710 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35711 35711 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35712 35712 fi
35713 35713 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
35714 35714 fi
35715 35715 fi
35716 35716
35717 35717 # Now new_path has a complete unix path to the binary
35718 35718 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
35719 35719 # Keep paths in /bin as-is, but remove trailing .exe if any
35720 35720 new_path="${new_path/%.exe/}"
35721 35721 # Do not save /bin paths to all_fixpath_prefixes!
35722 35722 else
35723 35723 # Not in mixed or Windows style, start by that.
35724 35724 new_path=`cmd //c echo $new_path`
35725 35725
35726 35726 input_path="$new_path"
35727 35727 # Check if we need to convert this using DOS-style short mode. If the path
35728 35728 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35729 35729 # take no chances and rewrite it.
35730 35730 # Note: m4 eats our [], so we need to use [ and ] instead.
35731 35731 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
35732 35732 if test "x$has_forbidden_chars" != x; then
35733 35733 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35734 35734 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35735 35735 fi
35736 35736
35737 35737 # Output is in $new_path
35738 35738
35739 35739 windows_path="$new_path"
35740 35740 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35741 35741 unix_path=`$CYGPATH -u "$windows_path"`
35742 35742 new_path="$unix_path"
35743 35743 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35744 35744 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35745 35745 new_path="$unix_path"
35746 35746 fi
35747 35747
35748 35748 # remove trailing .exe if any
35749 35749 new_path="${new_path/%.exe/}"
35750 35750
35751 35751 # Save the first 10 bytes of this path to the storage, so fixpath can work.
35752 35752 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
35753 35753 fi
35754 35754
35755 35755 else
35756 35756 # We're on a unix platform. Hooray! :)
35757 35757 # First separate the path from the arguments. This will split at the first
35758 35758 # space.
35759 35759 complete="$CPP"
35760 35760 path="${complete%% *}"
35761 35761 tmp="$complete EOL"
35762 35762 arguments="${tmp#* }"
35763 35763
35764 35764 # Cannot rely on the command "which" here since it doesn't always work.
35765 35765 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35766 35766 if test -z "$is_absolute_path"; then
35767 35767 # Path to executable is not absolute. Find it.
35768 35768 IFS_save="$IFS"
35769 35769 IFS=:
35770 35770 for p in $PATH; do
35771 35771 if test -f "$p/$path" && test -x "$p/$path"; then
35772 35772 new_path="$p/$path"
35773 35773 break
35774 35774 fi
35775 35775 done
35776 35776 IFS="$IFS_save"
35777 35777 else
35778 35778 # This is an absolute path, we can use it without further modifications.
35779 35779 new_path="$path"
35780 35780 fi
35781 35781
35782 35782 if test "x$new_path" = x; then
35783 35783 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
35784 35784 $as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
35785 35785 has_space=`$ECHO "$complete" | $GREP " "`
35786 35786 if test "x$has_space" != x; then
35787 35787 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
35788 35788 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
35789 35789 fi
35790 35790 as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
35791 35791 fi
35792 35792 fi
35793 35793
35794 35794 # Now join together the path and the arguments once again
35795 35795 if test "x$arguments" != xEOL; then
35796 35796 new_complete="$new_path ${arguments% *}"
35797 35797 else
35798 35798 new_complete="$new_path"
35799 35799 fi
35800 35800
35801 35801 if test "x$complete" != "x$new_complete"; then
35802 35802 CPP="$new_complete"
35803 35803 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
35804 35804 $as_echo "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
35805 35805 fi
35806 35806 fi
35807 35807
35808 35808 ac_ext=cpp
35809 35809 ac_cpp='$CXXCPP $CPPFLAGS'
35810 35810 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35811 35811 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35812 35812 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
35813 35813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
35814 35814 $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
35815 35815 if test -z "$CXXCPP"; then
35816 35816 if ${ac_cv_prog_CXXCPP+:} false; then :
35817 35817 $as_echo_n "(cached) " >&6
35818 35818 else
35819 35819 # Double quotes because CXXCPP needs to be expanded
35820 35820 for CXXCPP in "$CXX -E" "/lib/cpp"
35821 35821 do
35822 35822 ac_preproc_ok=false
35823 35823 for ac_cxx_preproc_warn_flag in '' yes
35824 35824 do
35825 35825 # Use a header file that comes with gcc, so configuring glibc
35826 35826 # with a fresh cross-compiler works.
35827 35827 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
35828 35828 # <limits.h> exists even on freestanding compilers.
35829 35829 # On the NeXT, cc -E runs the code through the compiler's parser,
35830 35830 # not just through cpp. "Syntax error" is here to catch this case.
35831 35831 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35832 35832 /* end confdefs.h. */
35833 35833 #ifdef __STDC__
35834 35834 # include <limits.h>
35835 35835 #else
35836 35836 # include <assert.h>
35837 35837 #endif
35838 35838 Syntax error
35839 35839 _ACEOF
35840 35840 if ac_fn_cxx_try_cpp "$LINENO"; then :
35841 35841
35842 35842 else
35843 35843 # Broken: fails on valid input.
35844 35844 continue
35845 35845 fi
35846 35846 rm -f conftest.err conftest.i conftest.$ac_ext
35847 35847
35848 35848 # OK, works on sane cases. Now check whether nonexistent headers
35849 35849 # can be detected and how.
35850 35850 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35851 35851 /* end confdefs.h. */
35852 35852 #include <ac_nonexistent.h>
35853 35853 _ACEOF
35854 35854 if ac_fn_cxx_try_cpp "$LINENO"; then :
35855 35855 # Broken: success on invalid input.
35856 35856 continue
35857 35857 else
35858 35858 # Passes both tests.
35859 35859 ac_preproc_ok=:
35860 35860 break
35861 35861 fi
35862 35862 rm -f conftest.err conftest.i conftest.$ac_ext
35863 35863
35864 35864 done
35865 35865 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
35866 35866 rm -f conftest.i conftest.err conftest.$ac_ext
35867 35867 if $ac_preproc_ok; then :
35868 35868 break
35869 35869 fi
35870 35870
35871 35871 done
35872 35872 ac_cv_prog_CXXCPP=$CXXCPP
35873 35873
35874 35874 fi
35875 35875 CXXCPP=$ac_cv_prog_CXXCPP
35876 35876 else
35877 35877 ac_cv_prog_CXXCPP=$CXXCPP
35878 35878 fi
35879 35879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
35880 35880 $as_echo "$CXXCPP" >&6; }
35881 35881 ac_preproc_ok=false
35882 35882 for ac_cxx_preproc_warn_flag in '' yes
35883 35883 do
35884 35884 # Use a header file that comes with gcc, so configuring glibc
35885 35885 # with a fresh cross-compiler works.
35886 35886 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
35887 35887 # <limits.h> exists even on freestanding compilers.
35888 35888 # On the NeXT, cc -E runs the code through the compiler's parser,
35889 35889 # not just through cpp. "Syntax error" is here to catch this case.
35890 35890 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35891 35891 /* end confdefs.h. */
35892 35892 #ifdef __STDC__
35893 35893 # include <limits.h>
35894 35894 #else
35895 35895 # include <assert.h>
35896 35896 #endif
35897 35897 Syntax error
35898 35898 _ACEOF
35899 35899 if ac_fn_cxx_try_cpp "$LINENO"; then :
35900 35900
35901 35901 else
35902 35902 # Broken: fails on valid input.
35903 35903 continue
35904 35904 fi
35905 35905 rm -f conftest.err conftest.i conftest.$ac_ext
35906 35906
35907 35907 # OK, works on sane cases. Now check whether nonexistent headers
35908 35908 # can be detected and how.
35909 35909 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
35910 35910 /* end confdefs.h. */
35911 35911 #include <ac_nonexistent.h>
35912 35912 _ACEOF
35913 35913 if ac_fn_cxx_try_cpp "$LINENO"; then :
35914 35914 # Broken: success on invalid input.
35915 35915 continue
35916 35916 else
35917 35917 # Passes both tests.
35918 35918 ac_preproc_ok=:
35919 35919 break
35920 35920 fi
35921 35921 rm -f conftest.err conftest.i conftest.$ac_ext
35922 35922
35923 35923 done
35924 35924 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
35925 35925 rm -f conftest.i conftest.err conftest.$ac_ext
35926 35926 if $ac_preproc_ok; then :
35927 35927
35928 35928 else
35929 35929 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
35930 35930 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
35931 35931 as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
35932 35932 See \`config.log' for more details" "$LINENO" 5; }
35933 35933 fi
35934 35934
35935 35935 ac_ext=cpp
35936 35936 ac_cpp='$CXXCPP $CPPFLAGS'
35937 35937 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
35938 35938 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
35939 35939 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
35940 35940
35941 35941
35942 35942 # Only process if variable expands to non-empty
35943 35943
35944 35944 if test "x$CXXCPP" != x; then
35945 35945 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35946 35946
35947 35947 # First separate the path from the arguments. This will split at the first
35948 35948 # space.
35949 35949 complete="$CXXCPP"
35950 35950 path="${complete%% *}"
35951 35951 tmp="$complete EOL"
35952 35952 arguments="${tmp#* }"
35953 35953
35954 35954 # Input might be given as Windows format, start by converting to
35955 35955 # unix format.
35956 35956 new_path=`$CYGPATH -u "$path"`
35957 35957
35958 35958 # Now try to locate executable using which
35959 35959 new_path=`$WHICH "$new_path" 2> /dev/null`
35960 35960 # bat and cmd files are not always considered executable in cygwin causing which
35961 35961 # to not find them
35962 35962 if test "x$new_path" = x \
35963 35963 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35964 35964 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35965 35965 new_path=`$CYGPATH -u "$path"`
35966 35966 fi
35967 35967 if test "x$new_path" = x; then
35968 35968 # Oops. Which didn't find the executable.
35969 35969 # The splitting of arguments from the executable at a space might have been incorrect,
35970 35970 # since paths with space are more likely in Windows. Give it another try with the whole
35971 35971 # argument.
35972 35972 path="$complete"
35973 35973 arguments="EOL"
35974 35974 new_path=`$CYGPATH -u "$path"`
35975 35975 new_path=`$WHICH "$new_path" 2> /dev/null`
35976 35976 # bat and cmd files are not always considered executable in cygwin causing which
35977 35977 # to not find them
35978 35978 if test "x$new_path" = x \
35979 35979 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
35980 35980 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
35981 35981 new_path=`$CYGPATH -u "$path"`
35982 35982 fi
35983 35983 if test "x$new_path" = x; then
35984 35984 # It's still not found. Now this is an unrecoverable error.
35985 35985 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
35986 35986 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
35987 35987 has_space=`$ECHO "$complete" | $GREP " "`
35988 35988 if test "x$has_space" != x; then
35989 35989 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
35990 35990 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
35991 35991 fi
35992 35992 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
35993 35993 fi
35994 35994 fi
35995 35995
35996 35996 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
35997 35997 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
35998 35998 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
35999 35999 # "foo.exe" is OK but "foo" is an error.
36000 36000 #
36001 36001 # This test is therefore slightly more accurate than "test -f" to check for file presence.
36002 36002 # It is also a way to make sure we got the proper file name for the real test later on.
36003 36003 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
36004 36004 if test "x$test_shortpath" = x; then
36005 36005 # Short path failed, file does not exist as specified.
36006 36006 # Try adding .exe or .cmd
36007 36007 if test -f "${new_path}.exe"; then
36008 36008 input_to_shortpath="${new_path}.exe"
36009 36009 elif test -f "${new_path}.cmd"; then
36010 36010 input_to_shortpath="${new_path}.cmd"
36011 36011 else
36012 36012 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
36013 36013 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
36014 36014 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
36015 36015 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
36016 36016 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
36017 36017 fi
36018 36018 else
36019 36019 input_to_shortpath="$new_path"
36020 36020 fi
36021 36021
36022 36022 # Call helper function which possibly converts this using DOS-style short mode.
36023 36023 # If so, the updated path is stored in $new_path.
36024 36024 new_path="$input_to_shortpath"
36025 36025
36026 36026 input_path="$input_to_shortpath"
36027 36027 # Check if we need to convert this using DOS-style short mode. If the path
36028 36028 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36029 36029 # take no chances and rewrite it.
36030 36030 # Note: m4 eats our [], so we need to use [ and ] instead.
36031 36031 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36032 36032 if test "x$has_forbidden_chars" != x; then
36033 36033 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36034 36034 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36035 36035 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36036 36036 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36037 36037 # Going to short mode and back again did indeed matter. Since short mode is
36038 36038 # case insensitive, let's make it lowercase to improve readability.
36039 36039 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36040 36040 # Now convert it back to Unix-style (cygpath)
36041 36041 input_path=`$CYGPATH -u "$shortmode_path"`
36042 36042 new_path="$input_path"
36043 36043 fi
36044 36044 fi
36045 36045
36046 36046 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36047 36047 if test "x$test_cygdrive_prefix" = x; then
36048 36048 # As a simple fix, exclude /usr/bin since it's not a real path.
36049 36049 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36050 36050 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36051 36051 # a path prefixed by /cygdrive for fixpath to work.
36052 36052 new_path="$CYGWIN_ROOT_PATH$input_path"
36053 36053 fi
36054 36054 fi
36055 36055
36056 36056 # remove trailing .exe if any
36057 36057 new_path="${new_path/%.exe/}"
36058 36058
36059 36059 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36060 36060
36061 36061 # First separate the path from the arguments. This will split at the first
36062 36062 # space.
36063 36063 complete="$CXXCPP"
36064 36064 path="${complete%% *}"
36065 36065 tmp="$complete EOL"
36066 36066 arguments="${tmp#* }"
36067 36067
36068 36068 # Input might be given as Windows format, start by converting to
36069 36069 # unix format.
36070 36070 new_path="$path"
36071 36071
36072 36072 windows_path="$new_path"
36073 36073 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36074 36074 unix_path=`$CYGPATH -u "$windows_path"`
36075 36075 new_path="$unix_path"
36076 36076 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36077 36077 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36078 36078 new_path="$unix_path"
36079 36079 fi
36080 36080
36081 36081
36082 36082 # Now try to locate executable using which
36083 36083 new_path=`$WHICH "$new_path" 2> /dev/null`
36084 36084
36085 36085 if test "x$new_path" = x; then
36086 36086 # Oops. Which didn't find the executable.
36087 36087 # The splitting of arguments from the executable at a space might have been incorrect,
36088 36088 # since paths with space are more likely in Windows. Give it another try with the whole
36089 36089 # argument.
36090 36090 path="$complete"
36091 36091 arguments="EOL"
36092 36092 new_path="$path"
36093 36093
36094 36094 windows_path="$new_path"
36095 36095 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36096 36096 unix_path=`$CYGPATH -u "$windows_path"`
36097 36097 new_path="$unix_path"
36098 36098 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36099 36099 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36100 36100 new_path="$unix_path"
36101 36101 fi
36102 36102
36103 36103
36104 36104 new_path=`$WHICH "$new_path" 2> /dev/null`
36105 36105 # bat and cmd files are not always considered executable in MSYS causing which
36106 36106 # to not find them
36107 36107 if test "x$new_path" = x \
36108 36108 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36109 36109 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36110 36110 new_path="$path"
36111 36111
36112 36112 windows_path="$new_path"
36113 36113 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36114 36114 unix_path=`$CYGPATH -u "$windows_path"`
36115 36115 new_path="$unix_path"
36116 36116 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36117 36117 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36118 36118 new_path="$unix_path"
36119 36119 fi
36120 36120
36121 36121 fi
36122 36122
36123 36123 if test "x$new_path" = x; then
36124 36124 # It's still not found. Now this is an unrecoverable error.
36125 36125 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
36126 36126 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
36127 36127 has_space=`$ECHO "$complete" | $GREP " "`
36128 36128 if test "x$has_space" != x; then
36129 36129 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36130 36130 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36131 36131 fi
36132 36132 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
36133 36133 fi
36134 36134 fi
36135 36135
36136 36136 # Now new_path has a complete unix path to the binary
36137 36137 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36138 36138 # Keep paths in /bin as-is, but remove trailing .exe if any
36139 36139 new_path="${new_path/%.exe/}"
36140 36140 # Do not save /bin paths to all_fixpath_prefixes!
36141 36141 else
36142 36142 # Not in mixed or Windows style, start by that.
36143 36143 new_path=`cmd //c echo $new_path`
36144 36144
36145 36145 input_path="$new_path"
36146 36146 # Check if we need to convert this using DOS-style short mode. If the path
36147 36147 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36148 36148 # take no chances and rewrite it.
36149 36149 # Note: m4 eats our [], so we need to use [ and ] instead.
36150 36150 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
36151 36151 if test "x$has_forbidden_chars" != x; then
36152 36152 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36153 36153 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36154 36154 fi
36155 36155
36156 36156 # Output is in $new_path
36157 36157
36158 36158 windows_path="$new_path"
36159 36159 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36160 36160 unix_path=`$CYGPATH -u "$windows_path"`
36161 36161 new_path="$unix_path"
36162 36162 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36163 36163 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36164 36164 new_path="$unix_path"
36165 36165 fi
36166 36166
36167 36167 # remove trailing .exe if any
36168 36168 new_path="${new_path/%.exe/}"
36169 36169
36170 36170 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36171 36171 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36172 36172 fi
36173 36173
36174 36174 else
36175 36175 # We're on a unix platform. Hooray! :)
36176 36176 # First separate the path from the arguments. This will split at the first
36177 36177 # space.
36178 36178 complete="$CXXCPP"
36179 36179 path="${complete%% *}"
36180 36180 tmp="$complete EOL"
36181 36181 arguments="${tmp#* }"
36182 36182
36183 36183 # Cannot rely on the command "which" here since it doesn't always work.
36184 36184 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36185 36185 if test -z "$is_absolute_path"; then
36186 36186 # Path to executable is not absolute. Find it.
36187 36187 IFS_save="$IFS"
36188 36188 IFS=:
36189 36189 for p in $PATH; do
36190 36190 if test -f "$p/$path" && test -x "$p/$path"; then
36191 36191 new_path="$p/$path"
36192 36192 break
36193 36193 fi
36194 36194 done
36195 36195 IFS="$IFS_save"
36196 36196 else
36197 36197 # This is an absolute path, we can use it without further modifications.
36198 36198 new_path="$path"
36199 36199 fi
36200 36200
36201 36201 if test "x$new_path" = x; then
36202 36202 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
36203 36203 $as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
36204 36204 has_space=`$ECHO "$complete" | $GREP " "`
36205 36205 if test "x$has_space" != x; then
36206 36206 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
36207 36207 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
36208 36208 fi
36209 36209 as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
36210 36210 fi
36211 36211 fi
36212 36212
36213 36213 # Now join together the path and the arguments once again
36214 36214 if test "x$arguments" != xEOL; then
36215 36215 new_complete="$new_path ${arguments% *}"
36216 36216 else
36217 36217 new_complete="$new_path"
36218 36218 fi
36219 36219
36220 36220 if test "x$complete" != "x$new_complete"; then
36221 36221 CXXCPP="$new_complete"
36222 36222 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
36223 36223 $as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
36224 36224 fi
36225 36225 fi
36226 36226
36227 36227
36228 36228 #
36229 36229 # Setup the linker (LD)
36230 36230 #
36231 36231 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
36232 36232 # In the Microsoft toolchain we have a separate LD command "link".
36233 36233 # Make sure we reject /usr/bin/link (as determined in CYGWIN_LINK), which is
36234 36234 # a cygwin program for something completely different.
36235 36235 # Extract the first word of "link", so it can be a program name with args.
36236 36236 set dummy link; ac_word=$2
36237 36237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36238 36238 $as_echo_n "checking for $ac_word... " >&6; }
36239 36239 if ${ac_cv_prog_LD+:} false; then :
36240 36240 $as_echo_n "(cached) " >&6
36241 36241 else
36242 36242 if test -n "$LD"; then
36243 36243 ac_cv_prog_LD="$LD" # Let the user override the test.
36244 36244 else
36245 36245 ac_prog_rejected=no
36246 36246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36247 36247 for as_dir in $PATH
36248 36248 do
36249 36249 IFS=$as_save_IFS
36250 36250 test -z "$as_dir" && as_dir=.
36251 36251 for ac_exec_ext in '' $ac_executable_extensions; do
36252 36252 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36253 36253 if test "$as_dir/$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
36254 36254 ac_prog_rejected=yes
36255 36255 continue
36256 36256 fi
36257 36257 ac_cv_prog_LD="link"
36258 36258 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36259 36259 break 2
36260 36260 fi
36261 36261 done
36262 36262 done
36263 36263 IFS=$as_save_IFS
36264 36264
36265 36265 if test $ac_prog_rejected = yes; then
36266 36266 # We found a bogon in the path, so make sure we never use it.
36267 36267 set dummy $ac_cv_prog_LD
36268 36268 shift
36269 36269 if test $# != 0; then
36270 36270 # We chose a different compiler from the bogus one.
36271 36271 # However, it has the same basename, so the bogon will be chosen
36272 36272 # first if we set LD to just the basename; use the full file name.
36273 36273 shift
36274 36274 ac_cv_prog_LD="$as_dir/$ac_word${1+' '}$@"
36275 36275 fi
36276 36276 fi
36277 36277 fi
36278 36278 fi
36279 36279 LD=$ac_cv_prog_LD
36280 36280 if test -n "$LD"; then
36281 36281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
36282 36282 $as_echo "$LD" >&6; }
36283 36283 else
36284 36284 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36285 36285 $as_echo "no" >&6; }
36286 36286 fi
36287 36287
36288 36288
36289 36289
36290 36290 # Only process if variable expands to non-empty
36291 36291
36292 36292 if test "x$LD" != x; then
36293 36293 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36294 36294
36295 36295 # First separate the path from the arguments. This will split at the first
36296 36296 # space.
36297 36297 complete="$LD"
36298 36298 path="${complete%% *}"
36299 36299 tmp="$complete EOL"
36300 36300 arguments="${tmp#* }"
36301 36301
36302 36302 # Input might be given as Windows format, start by converting to
36303 36303 # unix format.
36304 36304 new_path=`$CYGPATH -u "$path"`
36305 36305
36306 36306 # Now try to locate executable using which
36307 36307 new_path=`$WHICH "$new_path" 2> /dev/null`
36308 36308 # bat and cmd files are not always considered executable in cygwin causing which
36309 36309 # to not find them
36310 36310 if test "x$new_path" = x \
36311 36311 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36312 36312 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36313 36313 new_path=`$CYGPATH -u "$path"`
36314 36314 fi
36315 36315 if test "x$new_path" = x; then
36316 36316 # Oops. Which didn't find the executable.
36317 36317 # The splitting of arguments from the executable at a space might have been incorrect,
36318 36318 # since paths with space are more likely in Windows. Give it another try with the whole
36319 36319 # argument.
36320 36320 path="$complete"
36321 36321 arguments="EOL"
36322 36322 new_path=`$CYGPATH -u "$path"`
36323 36323 new_path=`$WHICH "$new_path" 2> /dev/null`
36324 36324 # bat and cmd files are not always considered executable in cygwin causing which
36325 36325 # to not find them
36326 36326 if test "x$new_path" = x \
36327 36327 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36328 36328 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36329 36329 new_path=`$CYGPATH -u "$path"`
36330 36330 fi
36331 36331 if test "x$new_path" = x; then
36332 36332 # It's still not found. Now this is an unrecoverable error.
36333 36333 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
36334 36334 $as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
36335 36335 has_space=`$ECHO "$complete" | $GREP " "`
36336 36336 if test "x$has_space" != x; then
36337 36337 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36338 36338 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36339 36339 fi
36340 36340 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
36341 36341 fi
36342 36342 fi
36343 36343
36344 36344 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
36345 36345 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
36346 36346 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
36347 36347 # "foo.exe" is OK but "foo" is an error.
36348 36348 #
36349 36349 # This test is therefore slightly more accurate than "test -f" to check for file presence.
36350 36350 # It is also a way to make sure we got the proper file name for the real test later on.
36351 36351 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
36352 36352 if test "x$test_shortpath" = x; then
36353 36353 # Short path failed, file does not exist as specified.
36354 36354 # Try adding .exe or .cmd
36355 36355 if test -f "${new_path}.exe"; then
36356 36356 input_to_shortpath="${new_path}.exe"
36357 36357 elif test -f "${new_path}.cmd"; then
36358 36358 input_to_shortpath="${new_path}.cmd"
36359 36359 else
36360 36360 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
36361 36361 $as_echo "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
36362 36362 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
36363 36363 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
36364 36364 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
36365 36365 fi
36366 36366 else
36367 36367 input_to_shortpath="$new_path"
36368 36368 fi
36369 36369
36370 36370 # Call helper function which possibly converts this using DOS-style short mode.
36371 36371 # If so, the updated path is stored in $new_path.
36372 36372 new_path="$input_to_shortpath"
36373 36373
36374 36374 input_path="$input_to_shortpath"
36375 36375 # Check if we need to convert this using DOS-style short mode. If the path
36376 36376 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36377 36377 # take no chances and rewrite it.
36378 36378 # Note: m4 eats our [], so we need to use [ and ] instead.
36379 36379 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36380 36380 if test "x$has_forbidden_chars" != x; then
36381 36381 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36382 36382 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36383 36383 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36384 36384 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36385 36385 # Going to short mode and back again did indeed matter. Since short mode is
36386 36386 # case insensitive, let's make it lowercase to improve readability.
36387 36387 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36388 36388 # Now convert it back to Unix-style (cygpath)
36389 36389 input_path=`$CYGPATH -u "$shortmode_path"`
36390 36390 new_path="$input_path"
36391 36391 fi
36392 36392 fi
36393 36393
36394 36394 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36395 36395 if test "x$test_cygdrive_prefix" = x; then
36396 36396 # As a simple fix, exclude /usr/bin since it's not a real path.
36397 36397 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36398 36398 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36399 36399 # a path prefixed by /cygdrive for fixpath to work.
36400 36400 new_path="$CYGWIN_ROOT_PATH$input_path"
36401 36401 fi
36402 36402 fi
36403 36403
36404 36404 # remove trailing .exe if any
36405 36405 new_path="${new_path/%.exe/}"
36406 36406
36407 36407 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36408 36408
36409 36409 # First separate the path from the arguments. This will split at the first
36410 36410 # space.
36411 36411 complete="$LD"
36412 36412 path="${complete%% *}"
36413 36413 tmp="$complete EOL"
36414 36414 arguments="${tmp#* }"
36415 36415
36416 36416 # Input might be given as Windows format, start by converting to
36417 36417 # unix format.
36418 36418 new_path="$path"
36419 36419
36420 36420 windows_path="$new_path"
36421 36421 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36422 36422 unix_path=`$CYGPATH -u "$windows_path"`
36423 36423 new_path="$unix_path"
36424 36424 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36425 36425 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36426 36426 new_path="$unix_path"
36427 36427 fi
36428 36428
36429 36429
36430 36430 # Now try to locate executable using which
36431 36431 new_path=`$WHICH "$new_path" 2> /dev/null`
36432 36432
36433 36433 if test "x$new_path" = x; then
36434 36434 # Oops. Which didn't find the executable.
36435 36435 # The splitting of arguments from the executable at a space might have been incorrect,
36436 36436 # since paths with space are more likely in Windows. Give it another try with the whole
36437 36437 # argument.
36438 36438 path="$complete"
36439 36439 arguments="EOL"
36440 36440 new_path="$path"
36441 36441
36442 36442 windows_path="$new_path"
36443 36443 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36444 36444 unix_path=`$CYGPATH -u "$windows_path"`
36445 36445 new_path="$unix_path"
36446 36446 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36447 36447 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36448 36448 new_path="$unix_path"
36449 36449 fi
36450 36450
36451 36451
36452 36452 new_path=`$WHICH "$new_path" 2> /dev/null`
36453 36453 # bat and cmd files are not always considered executable in MSYS causing which
36454 36454 # to not find them
36455 36455 if test "x$new_path" = x \
36456 36456 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36457 36457 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36458 36458 new_path="$path"
36459 36459
36460 36460 windows_path="$new_path"
36461 36461 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36462 36462 unix_path=`$CYGPATH -u "$windows_path"`
36463 36463 new_path="$unix_path"
36464 36464 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36465 36465 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36466 36466 new_path="$unix_path"
36467 36467 fi
36468 36468
36469 36469 fi
36470 36470
36471 36471 if test "x$new_path" = x; then
36472 36472 # It's still not found. Now this is an unrecoverable error.
36473 36473 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
36474 36474 $as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
36475 36475 has_space=`$ECHO "$complete" | $GREP " "`
36476 36476 if test "x$has_space" != x; then
36477 36477 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36478 36478 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36479 36479 fi
36480 36480 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
36481 36481 fi
36482 36482 fi
36483 36483
36484 36484 # Now new_path has a complete unix path to the binary
36485 36485 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36486 36486 # Keep paths in /bin as-is, but remove trailing .exe if any
36487 36487 new_path="${new_path/%.exe/}"
36488 36488 # Do not save /bin paths to all_fixpath_prefixes!
36489 36489 else
36490 36490 # Not in mixed or Windows style, start by that.
36491 36491 new_path=`cmd //c echo $new_path`
36492 36492
36493 36493 input_path="$new_path"
36494 36494 # Check if we need to convert this using DOS-style short mode. If the path
36495 36495 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36496 36496 # take no chances and rewrite it.
36497 36497 # Note: m4 eats our [], so we need to use [ and ] instead.
36498 36498 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
36499 36499 if test "x$has_forbidden_chars" != x; then
36500 36500 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36501 36501 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36502 36502 fi
36503 36503
36504 36504 # Output is in $new_path
36505 36505
36506 36506 windows_path="$new_path"
36507 36507 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36508 36508 unix_path=`$CYGPATH -u "$windows_path"`
36509 36509 new_path="$unix_path"
36510 36510 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36511 36511 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36512 36512 new_path="$unix_path"
36513 36513 fi
36514 36514
36515 36515 # remove trailing .exe if any
36516 36516 new_path="${new_path/%.exe/}"
36517 36517
36518 36518 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36519 36519 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36520 36520 fi
36521 36521
36522 36522 else
36523 36523 # We're on a unix platform. Hooray! :)
36524 36524 # First separate the path from the arguments. This will split at the first
36525 36525 # space.
36526 36526 complete="$LD"
36527 36527 path="${complete%% *}"
36528 36528 tmp="$complete EOL"
36529 36529 arguments="${tmp#* }"
36530 36530
36531 36531 # Cannot rely on the command "which" here since it doesn't always work.
36532 36532 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36533 36533 if test -z "$is_absolute_path"; then
36534 36534 # Path to executable is not absolute. Find it.
36535 36535 IFS_save="$IFS"
36536 36536 IFS=:
36537 36537 for p in $PATH; do
36538 36538 if test -f "$p/$path" && test -x "$p/$path"; then
36539 36539 new_path="$p/$path"
36540 36540 break
36541 36541 fi
36542 36542 done
36543 36543 IFS="$IFS_save"
36544 36544 else
36545 36545 # This is an absolute path, we can use it without further modifications.
36546 36546 new_path="$path"
36547 36547 fi
36548 36548
36549 36549 if test "x$new_path" = x; then
36550 36550 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
36551 36551 $as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
36552 36552 has_space=`$ECHO "$complete" | $GREP " "`
36553 36553 if test "x$has_space" != x; then
36554 36554 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
36555 36555 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
36556 36556 fi
36557 36557 as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
36558 36558 fi
36559 36559 fi
36560 36560
36561 36561 # Now join together the path and the arguments once again
36562 36562 if test "x$arguments" != xEOL; then
36563 36563 new_complete="$new_path ${arguments% *}"
36564 36564 else
36565 36565 new_complete="$new_path"
36566 36566 fi
36567 36567
36568 36568 if test "x$complete" != "x$new_complete"; then
36569 36569 LD="$new_complete"
36570 36570 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
36571 36571 $as_echo "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
36572 36572 fi
36573 36573 fi
36574 36574
36575 36575 # Verify that we indeed succeeded with this trick.
36576 36576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
36577 36577 $as_echo_n "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
36578 36578 "$LD" --version > /dev/null
36579 36579 if test $? -eq 0 ; then
36580 36580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36581 36581 $as_echo "no" >&6; }
36582 36582 as_fn_error $? "This is the Cygwin link tool. Please check your PATH and rerun configure." "$LINENO" 5
36583 36583 else
36584 36584 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
36585 36585 $as_echo "yes" >&6; }
36586 36586 fi
36587 36587 LDCXX="$LD"
36588 36588 else
36589 36589 # All other toolchains use the compiler to link.
36590 36590 LD="$CC"
36591 36591 LDCXX="$CXX"
36592 36592 fi
36593 36593
36594 36594 # FIXME: it should be CXXLD, according to standard (cf CXXCPP)
36595 36595
36596 36596
36597 36597 #
36598 36598 # Setup the assembler (AS)
36599 36599 #
36600 36600 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
36601 36601
36602 36602
36603 36603 # Publish this variable in the help.
36604 36604
36605 36605
36606 36606 if [ -z "${AS+x}" ]; then
36607 36607 # The variable is not set by user, try to locate tool using the code snippet
36608 36608 for ac_prog in as
36609 36609 do
36610 36610 # Extract the first word of "$ac_prog", so it can be a program name with args.
36611 36611 set dummy $ac_prog; ac_word=$2
36612 36612 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36613 36613 $as_echo_n "checking for $ac_word... " >&6; }
36614 36614 if ${ac_cv_path_AS+:} false; then :
36615 36615 $as_echo_n "(cached) " >&6
36616 36616 else
36617 36617 case $AS in
36618 36618 [\\/]* | ?:[\\/]*)
36619 36619 ac_cv_path_AS="$AS" # Let the user override the test with a path.
36620 36620 ;;
36621 36621 *)
36622 36622 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36623 36623 for as_dir in $PATH
36624 36624 do
36625 36625 IFS=$as_save_IFS
36626 36626 test -z "$as_dir" && as_dir=.
36627 36627 for ac_exec_ext in '' $ac_executable_extensions; do
36628 36628 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36629 36629 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
36630 36630 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36631 36631 break 2
36632 36632 fi
36633 36633 done
36634 36634 done
36635 36635 IFS=$as_save_IFS
36636 36636
36637 36637 ;;
36638 36638 esac
36639 36639 fi
36640 36640 AS=$ac_cv_path_AS
36641 36641 if test -n "$AS"; then
36642 36642 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
36643 36643 $as_echo "$AS" >&6; }
36644 36644 else
36645 36645 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36646 36646 $as_echo "no" >&6; }
36647 36647 fi
36648 36648
36649 36649
36650 36650 test -n "$AS" && break
36651 36651 done
36652 36652
36653 36653 else
36654 36654 # The variable is set, but is it from the command line or the environment?
36655 36655
36656 36656 # Try to remove the string !AS! from our list.
36657 36657 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AS!/}
36658 36658 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
36659 36659 # If it failed, the variable was not from the command line. Ignore it,
36660 36660 # but warn the user (except for BASH, which is always set by the calling BASH).
36661 36661 if test "xAS" != xBASH; then
36662 36662 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
36663 36663 $as_echo "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
36664 36664 fi
36665 36665 # Try to locate tool using the code snippet
36666 36666 for ac_prog in as
36667 36667 do
36668 36668 # Extract the first word of "$ac_prog", so it can be a program name with args.
36669 36669 set dummy $ac_prog; ac_word=$2
36670 36670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36671 36671 $as_echo_n "checking for $ac_word... " >&6; }
36672 36672 if ${ac_cv_path_AS+:} false; then :
36673 36673 $as_echo_n "(cached) " >&6
36674 36674 else
36675 36675 case $AS in
36676 36676 [\\/]* | ?:[\\/]*)
36677 36677 ac_cv_path_AS="$AS" # Let the user override the test with a path.
36678 36678 ;;
36679 36679 *)
36680 36680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36681 36681 for as_dir in $PATH
36682 36682 do
36683 36683 IFS=$as_save_IFS
36684 36684 test -z "$as_dir" && as_dir=.
36685 36685 for ac_exec_ext in '' $ac_executable_extensions; do
36686 36686 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36687 36687 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
36688 36688 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36689 36689 break 2
36690 36690 fi
36691 36691 done
36692 36692 done
36693 36693 IFS=$as_save_IFS
36694 36694
36695 36695 ;;
36696 36696 esac
36697 36697 fi
36698 36698 AS=$ac_cv_path_AS
36699 36699 if test -n "$AS"; then
36700 36700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
36701 36701 $as_echo "$AS" >&6; }
36702 36702 else
36703 36703 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36704 36704 $as_echo "no" >&6; }
36705 36705 fi
36706 36706
36707 36707
36708 36708 test -n "$AS" && break
36709 36709 done
36710 36710
36711 36711 else
36712 36712 # If it succeeded, then it was overridden by the user. We will use it
36713 36713 # for the tool.
36714 36714
36715 36715 # First remove it from the list of overridden variables, so we can test
36716 36716 # for unknown variables in the end.
36717 36717 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
36718 36718
36719 36719 # Check if we try to supply an empty value
36720 36720 if test "x$AS" = x; then
36721 36721 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AS= (no value)" >&5
36722 36722 $as_echo "$as_me: Setting user supplied tool AS= (no value)" >&6;}
36723 36723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
36724 36724 $as_echo_n "checking for AS... " >&6; }
36725 36725 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
36726 36726 $as_echo "disabled" >&6; }
36727 36727 else
36728 36728 # Check if the provided tool contains a complete path.
36729 36729 tool_specified="$AS"
36730 36730 tool_basename="${tool_specified##*/}"
36731 36731 if test "x$tool_basename" = "x$tool_specified"; then
36732 36732 # A command without a complete path is provided, search $PATH.
36733 36733 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
36734 36734 $as_echo "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
36735 36735 # Extract the first word of "$tool_basename", so it can be a program name with args.
36736 36736 set dummy $tool_basename; ac_word=$2
36737 36737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
36738 36738 $as_echo_n "checking for $ac_word... " >&6; }
36739 36739 if ${ac_cv_path_AS+:} false; then :
36740 36740 $as_echo_n "(cached) " >&6
36741 36741 else
36742 36742 case $AS in
36743 36743 [\\/]* | ?:[\\/]*)
36744 36744 ac_cv_path_AS="$AS" # Let the user override the test with a path.
36745 36745 ;;
36746 36746 *)
36747 36747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
36748 36748 for as_dir in $PATH
36749 36749 do
36750 36750 IFS=$as_save_IFS
36751 36751 test -z "$as_dir" && as_dir=.
36752 36752 for ac_exec_ext in '' $ac_executable_extensions; do
36753 36753 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
36754 36754 ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
36755 36755 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
36756 36756 break 2
36757 36757 fi
36758 36758 done
36759 36759 done
36760 36760 IFS=$as_save_IFS
36761 36761
36762 36762 ;;
36763 36763 esac
36764 36764 fi
36765 36765 AS=$ac_cv_path_AS
36766 36766 if test -n "$AS"; then
36767 36767 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
36768 36768 $as_echo "$AS" >&6; }
36769 36769 else
36770 36770 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
36771 36771 $as_echo "no" >&6; }
36772 36772 fi
36773 36773
36774 36774
36775 36775 if test "x$AS" = x; then
36776 36776 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
36777 36777 fi
36778 36778 else
36779 36779 # Otherwise we believe it is a complete path. Use it as it is.
36780 36780 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
36781 36781 $as_echo "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
36782 36782 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
36783 36783 $as_echo_n "checking for AS... " >&6; }
36784 36784 if test ! -x "$tool_specified"; then
36785 36785 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
36786 36786 $as_echo "not found" >&6; }
36787 36787 as_fn_error $? "User supplied tool AS=$tool_specified does not exist or is not executable" "$LINENO" 5
36788 36788 fi
36789 36789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
36790 36790 $as_echo "$tool_specified" >&6; }
36791 36791 fi
36792 36792 fi
36793 36793 fi
36794 36794
36795 36795 fi
36796 36796
36797 36797
36798 36798
36799 36799 # Only process if variable expands to non-empty
36800 36800
36801 36801 if test "x$AS" != x; then
36802 36802 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36803 36803
36804 36804 # First separate the path from the arguments. This will split at the first
36805 36805 # space.
36806 36806 complete="$AS"
36807 36807 path="${complete%% *}"
36808 36808 tmp="$complete EOL"
36809 36809 arguments="${tmp#* }"
36810 36810
36811 36811 # Input might be given as Windows format, start by converting to
36812 36812 # unix format.
36813 36813 new_path=`$CYGPATH -u "$path"`
36814 36814
36815 36815 # Now try to locate executable using which
36816 36816 new_path=`$WHICH "$new_path" 2> /dev/null`
36817 36817 # bat and cmd files are not always considered executable in cygwin causing which
36818 36818 # to not find them
36819 36819 if test "x$new_path" = x \
36820 36820 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36821 36821 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36822 36822 new_path=`$CYGPATH -u "$path"`
36823 36823 fi
36824 36824 if test "x$new_path" = x; then
36825 36825 # Oops. Which didn't find the executable.
36826 36826 # The splitting of arguments from the executable at a space might have been incorrect,
36827 36827 # since paths with space are more likely in Windows. Give it another try with the whole
36828 36828 # argument.
36829 36829 path="$complete"
36830 36830 arguments="EOL"
36831 36831 new_path=`$CYGPATH -u "$path"`
36832 36832 new_path=`$WHICH "$new_path" 2> /dev/null`
36833 36833 # bat and cmd files are not always considered executable in cygwin causing which
36834 36834 # to not find them
36835 36835 if test "x$new_path" = x \
36836 36836 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36837 36837 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36838 36838 new_path=`$CYGPATH -u "$path"`
36839 36839 fi
36840 36840 if test "x$new_path" = x; then
36841 36841 # It's still not found. Now this is an unrecoverable error.
36842 36842 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
36843 36843 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
36844 36844 has_space=`$ECHO "$complete" | $GREP " "`
36845 36845 if test "x$has_space" != x; then
36846 36846 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36847 36847 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36848 36848 fi
36849 36849 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
36850 36850 fi
36851 36851 fi
36852 36852
36853 36853 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
36854 36854 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
36855 36855 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
36856 36856 # "foo.exe" is OK but "foo" is an error.
36857 36857 #
36858 36858 # This test is therefore slightly more accurate than "test -f" to check for file presence.
36859 36859 # It is also a way to make sure we got the proper file name for the real test later on.
36860 36860 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
36861 36861 if test "x$test_shortpath" = x; then
36862 36862 # Short path failed, file does not exist as specified.
36863 36863 # Try adding .exe or .cmd
36864 36864 if test -f "${new_path}.exe"; then
36865 36865 input_to_shortpath="${new_path}.exe"
36866 36866 elif test -f "${new_path}.cmd"; then
36867 36867 input_to_shortpath="${new_path}.cmd"
36868 36868 else
36869 36869 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
36870 36870 $as_echo "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
36871 36871 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
36872 36872 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
36873 36873 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
36874 36874 fi
36875 36875 else
36876 36876 input_to_shortpath="$new_path"
36877 36877 fi
36878 36878
36879 36879 # Call helper function which possibly converts this using DOS-style short mode.
36880 36880 # If so, the updated path is stored in $new_path.
36881 36881 new_path="$input_to_shortpath"
36882 36882
36883 36883 input_path="$input_to_shortpath"
36884 36884 # Check if we need to convert this using DOS-style short mode. If the path
36885 36885 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36886 36886 # take no chances and rewrite it.
36887 36887 # Note: m4 eats our [], so we need to use [ and ] instead.
36888 36888 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36889 36889 if test "x$has_forbidden_chars" != x; then
36890 36890 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36891 36891 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36892 36892 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36893 36893 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36894 36894 # Going to short mode and back again did indeed matter. Since short mode is
36895 36895 # case insensitive, let's make it lowercase to improve readability.
36896 36896 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36897 36897 # Now convert it back to Unix-style (cygpath)
36898 36898 input_path=`$CYGPATH -u "$shortmode_path"`
36899 36899 new_path="$input_path"
36900 36900 fi
36901 36901 fi
36902 36902
36903 36903 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36904 36904 if test "x$test_cygdrive_prefix" = x; then
36905 36905 # As a simple fix, exclude /usr/bin since it's not a real path.
36906 36906 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36907 36907 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36908 36908 # a path prefixed by /cygdrive for fixpath to work.
36909 36909 new_path="$CYGWIN_ROOT_PATH$input_path"
36910 36910 fi
36911 36911 fi
36912 36912
36913 36913 # remove trailing .exe if any
36914 36914 new_path="${new_path/%.exe/}"
36915 36915
36916 36916 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36917 36917
36918 36918 # First separate the path from the arguments. This will split at the first
36919 36919 # space.
36920 36920 complete="$AS"
36921 36921 path="${complete%% *}"
36922 36922 tmp="$complete EOL"
36923 36923 arguments="${tmp#* }"
36924 36924
36925 36925 # Input might be given as Windows format, start by converting to
36926 36926 # unix format.
36927 36927 new_path="$path"
36928 36928
36929 36929 windows_path="$new_path"
36930 36930 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36931 36931 unix_path=`$CYGPATH -u "$windows_path"`
36932 36932 new_path="$unix_path"
36933 36933 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36934 36934 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36935 36935 new_path="$unix_path"
36936 36936 fi
36937 36937
36938 36938
36939 36939 # Now try to locate executable using which
36940 36940 new_path=`$WHICH "$new_path" 2> /dev/null`
36941 36941
36942 36942 if test "x$new_path" = x; then
36943 36943 # Oops. Which didn't find the executable.
36944 36944 # The splitting of arguments from the executable at a space might have been incorrect,
36945 36945 # since paths with space are more likely in Windows. Give it another try with the whole
36946 36946 # argument.
36947 36947 path="$complete"
36948 36948 arguments="EOL"
36949 36949 new_path="$path"
36950 36950
36951 36951 windows_path="$new_path"
36952 36952 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36953 36953 unix_path=`$CYGPATH -u "$windows_path"`
36954 36954 new_path="$unix_path"
36955 36955 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36956 36956 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36957 36957 new_path="$unix_path"
36958 36958 fi
36959 36959
36960 36960
36961 36961 new_path=`$WHICH "$new_path" 2> /dev/null`
36962 36962 # bat and cmd files are not always considered executable in MSYS causing which
36963 36963 # to not find them
36964 36964 if test "x$new_path" = x \
36965 36965 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
36966 36966 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
36967 36967 new_path="$path"
36968 36968
36969 36969 windows_path="$new_path"
36970 36970 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36971 36971 unix_path=`$CYGPATH -u "$windows_path"`
36972 36972 new_path="$unix_path"
36973 36973 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36974 36974 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36975 36975 new_path="$unix_path"
36976 36976 fi
36977 36977
36978 36978 fi
36979 36979
36980 36980 if test "x$new_path" = x; then
36981 36981 # It's still not found. Now this is an unrecoverable error.
36982 36982 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
36983 36983 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
36984 36984 has_space=`$ECHO "$complete" | $GREP " "`
36985 36985 if test "x$has_space" != x; then
36986 36986 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
36987 36987 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
36988 36988 fi
36989 36989 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
36990 36990 fi
36991 36991 fi
36992 36992
36993 36993 # Now new_path has a complete unix path to the binary
36994 36994 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
36995 36995 # Keep paths in /bin as-is, but remove trailing .exe if any
36996 36996 new_path="${new_path/%.exe/}"
36997 36997 # Do not save /bin paths to all_fixpath_prefixes!
36998 36998 else
36999 36999 # Not in mixed or Windows style, start by that.
37000 37000 new_path=`cmd //c echo $new_path`
37001 37001
37002 37002 input_path="$new_path"
37003 37003 # Check if we need to convert this using DOS-style short mode. If the path
37004 37004 # contains just simple characters, use it. Otherwise (spaces, weird characters),
37005 37005 # take no chances and rewrite it.
37006 37006 # Note: m4 eats our [], so we need to use [ and ] instead.
37007 37007 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
37008 37008 if test "x$has_forbidden_chars" != x; then
37009 37009 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
37010 37010 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
37011 37011 fi
37012 37012
37013 37013 # Output is in $new_path
37014 37014
37015 37015 windows_path="$new_path"
37016 37016 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37017 37017 unix_path=`$CYGPATH -u "$windows_path"`
37018 37018 new_path="$unix_path"
37019 37019 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37020 37020 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37021 37021 new_path="$unix_path"
37022 37022 fi
37023 37023
37024 37024 # remove trailing .exe if any
37025 37025 new_path="${new_path/%.exe/}"
37026 37026
37027 37027 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37028 37028 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37029 37029 fi
37030 37030
37031 37031 else
37032 37032 # We're on a unix platform. Hooray! :)
37033 37033 # First separate the path from the arguments. This will split at the first
37034 37034 # space.
37035 37035 complete="$AS"
37036 37036 path="${complete%% *}"
37037 37037 tmp="$complete EOL"
37038 37038 arguments="${tmp#* }"
37039 37039
37040 37040 # Cannot rely on the command "which" here since it doesn't always work.
37041 37041 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37042 37042 if test -z "$is_absolute_path"; then
37043 37043 # Path to executable is not absolute. Find it.
37044 37044 IFS_save="$IFS"
37045 37045 IFS=:
37046 37046 for p in $PATH; do
37047 37047 if test -f "$p/$path" && test -x "$p/$path"; then
37048 37048 new_path="$p/$path"
37049 37049 break
37050 37050 fi
37051 37051 done
37052 37052 IFS="$IFS_save"
37053 37053 else
37054 37054 # This is an absolute path, we can use it without further modifications.
37055 37055 new_path="$path"
37056 37056 fi
37057 37057
37058 37058 if test "x$new_path" = x; then
37059 37059 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
37060 37060 $as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
37061 37061 has_space=`$ECHO "$complete" | $GREP " "`
37062 37062 if test "x$has_space" != x; then
37063 37063 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
37064 37064 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
37065 37065 fi
37066 37066 as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
37067 37067 fi
37068 37068 fi
37069 37069
37070 37070 # Now join together the path and the arguments once again
37071 37071 if test "x$arguments" != xEOL; then
37072 37072 new_complete="$new_path ${arguments% *}"
37073 37073 else
37074 37074 new_complete="$new_path"
37075 37075 fi
37076 37076
37077 37077 if test "x$complete" != "x$new_complete"; then
37078 37078 AS="$new_complete"
37079 37079 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
37080 37080 $as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
37081 37081 fi
37082 37082 fi
37083 37083
37084 37084 if test "x$AS" = x; then
37085 37085 as_fn_error $? "Solaris assembler (as) is required. Please install via \"pkg install pkg:/developer/assembler\"." "$LINENO" 5
37086 37086 fi
37087 37087 else
37088 37088 # FIXME: is this correct for microsoft?
37089 37089 AS="$CC -c"
37090 37090 fi
37091 37091
37092 37092
37093 37093 #
37094 37094 # Setup the archiver (AR)
37095 37095 #
37096 37096 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
37097 37097 # The corresponding ar tool is lib.exe (used to create static libraries)
37098 37098 # Extract the first word of "lib", so it can be a program name with args.
37099 37099 set dummy lib; ac_word=$2
37100 37100 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37101 37101 $as_echo_n "checking for $ac_word... " >&6; }
37102 37102 if ${ac_cv_prog_AR+:} false; then :
37103 37103 $as_echo_n "(cached) " >&6
37104 37104 else
37105 37105 if test -n "$AR"; then
37106 37106 ac_cv_prog_AR="$AR" # Let the user override the test.
37107 37107 else
37108 37108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37109 37109 for as_dir in $PATH
37110 37110 do
37111 37111 IFS=$as_save_IFS
37112 37112 test -z "$as_dir" && as_dir=.
37113 37113 for ac_exec_ext in '' $ac_executable_extensions; do
37114 37114 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37115 37115 ac_cv_prog_AR="lib"
37116 37116 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37117 37117 break 2
37118 37118 fi
37119 37119 done
37120 37120 done
37121 37121 IFS=$as_save_IFS
37122 37122
37123 37123 fi
37124 37124 fi
37125 37125 AR=$ac_cv_prog_AR
37126 37126 if test -n "$AR"; then
37127 37127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37128 37128 $as_echo "$AR" >&6; }
37129 37129 else
37130 37130 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37131 37131 $as_echo "no" >&6; }
37132 37132 fi
37133 37133
37134 37134
37135 37135 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
37136 37136
37137 37137
37138 37138 # Publish this variable in the help.
37139 37139
37140 37140
37141 37141 if [ -z "${AR+x}" ]; then
37142 37142 # The variable is not set by user, try to locate tool using the code snippet
37143 37143 if test -n "$ac_tool_prefix"; then
37144 37144 for ac_prog in ar gcc-ar
37145 37145 do
37146 37146 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37147 37147 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37148 37148 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37149 37149 $as_echo_n "checking for $ac_word... " >&6; }
37150 37150 if ${ac_cv_prog_AR+:} false; then :
37151 37151 $as_echo_n "(cached) " >&6
37152 37152 else
37153 37153 if test -n "$AR"; then
37154 37154 ac_cv_prog_AR="$AR" # Let the user override the test.
37155 37155 else
37156 37156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37157 37157 for as_dir in $PATH
37158 37158 do
37159 37159 IFS=$as_save_IFS
37160 37160 test -z "$as_dir" && as_dir=.
37161 37161 for ac_exec_ext in '' $ac_executable_extensions; do
37162 37162 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37163 37163 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
37164 37164 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37165 37165 break 2
37166 37166 fi
37167 37167 done
37168 37168 done
37169 37169 IFS=$as_save_IFS
37170 37170
37171 37171 fi
37172 37172 fi
37173 37173 AR=$ac_cv_prog_AR
37174 37174 if test -n "$AR"; then
37175 37175 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37176 37176 $as_echo "$AR" >&6; }
37177 37177 else
37178 37178 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37179 37179 $as_echo "no" >&6; }
37180 37180 fi
37181 37181
37182 37182
37183 37183 test -n "$AR" && break
37184 37184 done
37185 37185 fi
37186 37186 if test -z "$AR"; then
37187 37187 ac_ct_AR=$AR
37188 37188 for ac_prog in ar gcc-ar
37189 37189 do
37190 37190 # Extract the first word of "$ac_prog", so it can be a program name with args.
37191 37191 set dummy $ac_prog; ac_word=$2
37192 37192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37193 37193 $as_echo_n "checking for $ac_word... " >&6; }
37194 37194 if ${ac_cv_prog_ac_ct_AR+:} false; then :
37195 37195 $as_echo_n "(cached) " >&6
37196 37196 else
37197 37197 if test -n "$ac_ct_AR"; then
37198 37198 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
37199 37199 else
37200 37200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37201 37201 for as_dir in $PATH
37202 37202 do
37203 37203 IFS=$as_save_IFS
37204 37204 test -z "$as_dir" && as_dir=.
37205 37205 for ac_exec_ext in '' $ac_executable_extensions; do
37206 37206 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37207 37207 ac_cv_prog_ac_ct_AR="$ac_prog"
37208 37208 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37209 37209 break 2
37210 37210 fi
37211 37211 done
37212 37212 done
37213 37213 IFS=$as_save_IFS
37214 37214
37215 37215 fi
37216 37216 fi
37217 37217 ac_ct_AR=$ac_cv_prog_ac_ct_AR
37218 37218 if test -n "$ac_ct_AR"; then
37219 37219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
37220 37220 $as_echo "$ac_ct_AR" >&6; }
37221 37221 else
37222 37222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37223 37223 $as_echo "no" >&6; }
37224 37224 fi
37225 37225
37226 37226
37227 37227 test -n "$ac_ct_AR" && break
37228 37228 done
37229 37229
37230 37230 if test "x$ac_ct_AR" = x; then
37231 37231 AR=""
37232 37232 else
37233 37233 case $cross_compiling:$ac_tool_warned in
37234 37234 yes:)
37235 37235 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37236 37236 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37237 37237 ac_tool_warned=yes ;;
37238 37238 esac
37239 37239 AR=$ac_ct_AR
37240 37240 fi
37241 37241 fi
37242 37242
37243 37243 else
37244 37244 # The variable is set, but is it from the command line or the environment?
37245 37245
37246 37246 # Try to remove the string !AR! from our list.
37247 37247 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AR!/}
37248 37248 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
37249 37249 # If it failed, the variable was not from the command line. Ignore it,
37250 37250 # but warn the user (except for BASH, which is always set by the calling BASH).
37251 37251 if test "xAR" != xBASH; then
37252 37252 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
37253 37253 $as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
37254 37254 fi
37255 37255 # Try to locate tool using the code snippet
37256 37256 if test -n "$ac_tool_prefix"; then
37257 37257 for ac_prog in ar gcc-ar
37258 37258 do
37259 37259 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37260 37260 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37261 37261 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37262 37262 $as_echo_n "checking for $ac_word... " >&6; }
37263 37263 if ${ac_cv_prog_AR+:} false; then :
37264 37264 $as_echo_n "(cached) " >&6
37265 37265 else
37266 37266 if test -n "$AR"; then
37267 37267 ac_cv_prog_AR="$AR" # Let the user override the test.
37268 37268 else
37269 37269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37270 37270 for as_dir in $PATH
37271 37271 do
37272 37272 IFS=$as_save_IFS
37273 37273 test -z "$as_dir" && as_dir=.
37274 37274 for ac_exec_ext in '' $ac_executable_extensions; do
37275 37275 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37276 37276 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
37277 37277 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37278 37278 break 2
37279 37279 fi
37280 37280 done
37281 37281 done
37282 37282 IFS=$as_save_IFS
37283 37283
37284 37284 fi
37285 37285 fi
37286 37286 AR=$ac_cv_prog_AR
37287 37287 if test -n "$AR"; then
37288 37288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37289 37289 $as_echo "$AR" >&6; }
37290 37290 else
37291 37291 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37292 37292 $as_echo "no" >&6; }
37293 37293 fi
37294 37294
37295 37295
37296 37296 test -n "$AR" && break
37297 37297 done
37298 37298 fi
37299 37299 if test -z "$AR"; then
37300 37300 ac_ct_AR=$AR
37301 37301 for ac_prog in ar gcc-ar
37302 37302 do
37303 37303 # Extract the first word of "$ac_prog", so it can be a program name with args.
37304 37304 set dummy $ac_prog; ac_word=$2
37305 37305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37306 37306 $as_echo_n "checking for $ac_word... " >&6; }
37307 37307 if ${ac_cv_prog_ac_ct_AR+:} false; then :
37308 37308 $as_echo_n "(cached) " >&6
37309 37309 else
37310 37310 if test -n "$ac_ct_AR"; then
37311 37311 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
37312 37312 else
37313 37313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37314 37314 for as_dir in $PATH
37315 37315 do
37316 37316 IFS=$as_save_IFS
37317 37317 test -z "$as_dir" && as_dir=.
37318 37318 for ac_exec_ext in '' $ac_executable_extensions; do
37319 37319 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37320 37320 ac_cv_prog_ac_ct_AR="$ac_prog"
37321 37321 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37322 37322 break 2
37323 37323 fi
37324 37324 done
37325 37325 done
37326 37326 IFS=$as_save_IFS
37327 37327
37328 37328 fi
37329 37329 fi
37330 37330 ac_ct_AR=$ac_cv_prog_ac_ct_AR
37331 37331 if test -n "$ac_ct_AR"; then
37332 37332 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
37333 37333 $as_echo "$ac_ct_AR" >&6; }
37334 37334 else
37335 37335 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37336 37336 $as_echo "no" >&6; }
37337 37337 fi
37338 37338
37339 37339
37340 37340 test -n "$ac_ct_AR" && break
37341 37341 done
37342 37342
37343 37343 if test "x$ac_ct_AR" = x; then
37344 37344 AR=""
37345 37345 else
37346 37346 case $cross_compiling:$ac_tool_warned in
37347 37347 yes:)
37348 37348 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37349 37349 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37350 37350 ac_tool_warned=yes ;;
37351 37351 esac
37352 37352 AR=$ac_ct_AR
37353 37353 fi
37354 37354 fi
37355 37355
37356 37356 else
37357 37357 # If it succeeded, then it was overridden by the user. We will use it
37358 37358 # for the tool.
37359 37359
37360 37360 # First remove it from the list of overridden variables, so we can test
37361 37361 # for unknown variables in the end.
37362 37362 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
37363 37363
37364 37364 # Check if we try to supply an empty value
37365 37365 if test "x$AR" = x; then
37366 37366 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AR= (no value)" >&5
37367 37367 $as_echo "$as_me: Setting user supplied tool AR= (no value)" >&6;}
37368 37368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
37369 37369 $as_echo_n "checking for AR... " >&6; }
37370 37370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
37371 37371 $as_echo "disabled" >&6; }
37372 37372 else
37373 37373 # Check if the provided tool contains a complete path.
37374 37374 tool_specified="$AR"
37375 37375 tool_basename="${tool_specified##*/}"
37376 37376 if test "x$tool_basename" = "x$tool_specified"; then
37377 37377 # A command without a complete path is provided, search $PATH.
37378 37378 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
37379 37379 $as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
37380 37380 # Extract the first word of "$tool_basename", so it can be a program name with args.
37381 37381 set dummy $tool_basename; ac_word=$2
37382 37382 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37383 37383 $as_echo_n "checking for $ac_word... " >&6; }
37384 37384 if ${ac_cv_path_AR+:} false; then :
37385 37385 $as_echo_n "(cached) " >&6
37386 37386 else
37387 37387 case $AR in
37388 37388 [\\/]* | ?:[\\/]*)
37389 37389 ac_cv_path_AR="$AR" # Let the user override the test with a path.
37390 37390 ;;
37391 37391 *)
37392 37392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37393 37393 for as_dir in $PATH
37394 37394 do
37395 37395 IFS=$as_save_IFS
37396 37396 test -z "$as_dir" && as_dir=.
37397 37397 for ac_exec_ext in '' $ac_executable_extensions; do
37398 37398 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37399 37399 ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
37400 37400 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37401 37401 break 2
37402 37402 fi
37403 37403 done
37404 37404 done
37405 37405 IFS=$as_save_IFS
37406 37406
37407 37407 ;;
37408 37408 esac
37409 37409 fi
37410 37410 AR=$ac_cv_path_AR
37411 37411 if test -n "$AR"; then
37412 37412 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37413 37413 $as_echo "$AR" >&6; }
37414 37414 else
37415 37415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37416 37416 $as_echo "no" >&6; }
37417 37417 fi
37418 37418
37419 37419
37420 37420 if test "x$AR" = x; then
37421 37421 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
37422 37422 fi
37423 37423 else
37424 37424 # Otherwise we believe it is a complete path. Use it as it is.
37425 37425 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
37426 37426 $as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
37427 37427 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
37428 37428 $as_echo_n "checking for AR... " >&6; }
37429 37429 if test ! -x "$tool_specified"; then
37430 37430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
37431 37431 $as_echo "not found" >&6; }
37432 37432 as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
37433 37433 fi
37434 37434 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
37435 37435 $as_echo "$tool_specified" >&6; }
37436 37436 fi
37437 37437 fi
37438 37438 fi
37439 37439
37440 37440 fi
37441 37441
37442 37442
37443 37443 else
37444 37444
37445 37445
37446 37446 # Publish this variable in the help.
37447 37447
37448 37448
37449 37449 if [ -z "${AR+x}" ]; then
37450 37450 # The variable is not set by user, try to locate tool using the code snippet
37451 37451 if test -n "$ac_tool_prefix"; then
37452 37452 for ac_prog in ar
37453 37453 do
37454 37454 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37455 37455 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37456 37456 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37457 37457 $as_echo_n "checking for $ac_word... " >&6; }
37458 37458 if ${ac_cv_prog_AR+:} false; then :
37459 37459 $as_echo_n "(cached) " >&6
37460 37460 else
37461 37461 if test -n "$AR"; then
37462 37462 ac_cv_prog_AR="$AR" # Let the user override the test.
37463 37463 else
37464 37464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37465 37465 for as_dir in $PATH
37466 37466 do
37467 37467 IFS=$as_save_IFS
37468 37468 test -z "$as_dir" && as_dir=.
37469 37469 for ac_exec_ext in '' $ac_executable_extensions; do
37470 37470 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37471 37471 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
37472 37472 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37473 37473 break 2
37474 37474 fi
37475 37475 done
37476 37476 done
37477 37477 IFS=$as_save_IFS
37478 37478
37479 37479 fi
37480 37480 fi
37481 37481 AR=$ac_cv_prog_AR
37482 37482 if test -n "$AR"; then
37483 37483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37484 37484 $as_echo "$AR" >&6; }
37485 37485 else
37486 37486 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37487 37487 $as_echo "no" >&6; }
37488 37488 fi
37489 37489
37490 37490
37491 37491 test -n "$AR" && break
37492 37492 done
37493 37493 fi
37494 37494 if test -z "$AR"; then
37495 37495 ac_ct_AR=$AR
37496 37496 for ac_prog in ar
37497 37497 do
37498 37498 # Extract the first word of "$ac_prog", so it can be a program name with args.
37499 37499 set dummy $ac_prog; ac_word=$2
37500 37500 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37501 37501 $as_echo_n "checking for $ac_word... " >&6; }
37502 37502 if ${ac_cv_prog_ac_ct_AR+:} false; then :
37503 37503 $as_echo_n "(cached) " >&6
37504 37504 else
37505 37505 if test -n "$ac_ct_AR"; then
37506 37506 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
37507 37507 else
37508 37508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37509 37509 for as_dir in $PATH
37510 37510 do
37511 37511 IFS=$as_save_IFS
37512 37512 test -z "$as_dir" && as_dir=.
37513 37513 for ac_exec_ext in '' $ac_executable_extensions; do
37514 37514 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37515 37515 ac_cv_prog_ac_ct_AR="$ac_prog"
37516 37516 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37517 37517 break 2
37518 37518 fi
37519 37519 done
37520 37520 done
37521 37521 IFS=$as_save_IFS
37522 37522
37523 37523 fi
37524 37524 fi
37525 37525 ac_ct_AR=$ac_cv_prog_ac_ct_AR
37526 37526 if test -n "$ac_ct_AR"; then
37527 37527 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
37528 37528 $as_echo "$ac_ct_AR" >&6; }
37529 37529 else
37530 37530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37531 37531 $as_echo "no" >&6; }
37532 37532 fi
37533 37533
37534 37534
37535 37535 test -n "$ac_ct_AR" && break
37536 37536 done
37537 37537
37538 37538 if test "x$ac_ct_AR" = x; then
37539 37539 AR=""
37540 37540 else
37541 37541 case $cross_compiling:$ac_tool_warned in
37542 37542 yes:)
37543 37543 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37544 37544 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37545 37545 ac_tool_warned=yes ;;
37546 37546 esac
37547 37547 AR=$ac_ct_AR
37548 37548 fi
37549 37549 fi
37550 37550
37551 37551 else
37552 37552 # The variable is set, but is it from the command line or the environment?
37553 37553
37554 37554 # Try to remove the string !AR! from our list.
37555 37555 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AR!/}
37556 37556 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
37557 37557 # If it failed, the variable was not from the command line. Ignore it,
37558 37558 # but warn the user (except for BASH, which is always set by the calling BASH).
37559 37559 if test "xAR" != xBASH; then
37560 37560 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
37561 37561 $as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
37562 37562 fi
37563 37563 # Try to locate tool using the code snippet
37564 37564 if test -n "$ac_tool_prefix"; then
37565 37565 for ac_prog in ar
37566 37566 do
37567 37567 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
37568 37568 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
37569 37569 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37570 37570 $as_echo_n "checking for $ac_word... " >&6; }
37571 37571 if ${ac_cv_prog_AR+:} false; then :
37572 37572 $as_echo_n "(cached) " >&6
37573 37573 else
37574 37574 if test -n "$AR"; then
37575 37575 ac_cv_prog_AR="$AR" # Let the user override the test.
37576 37576 else
37577 37577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37578 37578 for as_dir in $PATH
37579 37579 do
37580 37580 IFS=$as_save_IFS
37581 37581 test -z "$as_dir" && as_dir=.
37582 37582 for ac_exec_ext in '' $ac_executable_extensions; do
37583 37583 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37584 37584 ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
37585 37585 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37586 37586 break 2
37587 37587 fi
37588 37588 done
37589 37589 done
37590 37590 IFS=$as_save_IFS
37591 37591
37592 37592 fi
37593 37593 fi
37594 37594 AR=$ac_cv_prog_AR
37595 37595 if test -n "$AR"; then
37596 37596 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37597 37597 $as_echo "$AR" >&6; }
37598 37598 else
37599 37599 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37600 37600 $as_echo "no" >&6; }
37601 37601 fi
37602 37602
37603 37603
37604 37604 test -n "$AR" && break
37605 37605 done
37606 37606 fi
37607 37607 if test -z "$AR"; then
37608 37608 ac_ct_AR=$AR
37609 37609 for ac_prog in ar
37610 37610 do
37611 37611 # Extract the first word of "$ac_prog", so it can be a program name with args.
37612 37612 set dummy $ac_prog; ac_word=$2
37613 37613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37614 37614 $as_echo_n "checking for $ac_word... " >&6; }
37615 37615 if ${ac_cv_prog_ac_ct_AR+:} false; then :
37616 37616 $as_echo_n "(cached) " >&6
37617 37617 else
37618 37618 if test -n "$ac_ct_AR"; then
37619 37619 ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
37620 37620 else
37621 37621 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37622 37622 for as_dir in $PATH
37623 37623 do
37624 37624 IFS=$as_save_IFS
37625 37625 test -z "$as_dir" && as_dir=.
37626 37626 for ac_exec_ext in '' $ac_executable_extensions; do
37627 37627 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37628 37628 ac_cv_prog_ac_ct_AR="$ac_prog"
37629 37629 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37630 37630 break 2
37631 37631 fi
37632 37632 done
37633 37633 done
37634 37634 IFS=$as_save_IFS
37635 37635
37636 37636 fi
37637 37637 fi
37638 37638 ac_ct_AR=$ac_cv_prog_ac_ct_AR
37639 37639 if test -n "$ac_ct_AR"; then
37640 37640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
37641 37641 $as_echo "$ac_ct_AR" >&6; }
37642 37642 else
37643 37643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37644 37644 $as_echo "no" >&6; }
37645 37645 fi
37646 37646
37647 37647
37648 37648 test -n "$ac_ct_AR" && break
37649 37649 done
37650 37650
37651 37651 if test "x$ac_ct_AR" = x; then
37652 37652 AR=""
37653 37653 else
37654 37654 case $cross_compiling:$ac_tool_warned in
37655 37655 yes:)
37656 37656 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
37657 37657 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
37658 37658 ac_tool_warned=yes ;;
37659 37659 esac
37660 37660 AR=$ac_ct_AR
37661 37661 fi
37662 37662 fi
37663 37663
37664 37664 else
37665 37665 # If it succeeded, then it was overridden by the user. We will use it
37666 37666 # for the tool.
37667 37667
37668 37668 # First remove it from the list of overridden variables, so we can test
37669 37669 # for unknown variables in the end.
37670 37670 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
37671 37671
37672 37672 # Check if we try to supply an empty value
37673 37673 if test "x$AR" = x; then
37674 37674 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AR= (no value)" >&5
37675 37675 $as_echo "$as_me: Setting user supplied tool AR= (no value)" >&6;}
37676 37676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
37677 37677 $as_echo_n "checking for AR... " >&6; }
37678 37678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
37679 37679 $as_echo "disabled" >&6; }
37680 37680 else
37681 37681 # Check if the provided tool contains a complete path.
37682 37682 tool_specified="$AR"
37683 37683 tool_basename="${tool_specified##*/}"
37684 37684 if test "x$tool_basename" = "x$tool_specified"; then
37685 37685 # A command without a complete path is provided, search $PATH.
37686 37686 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
37687 37687 $as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
37688 37688 # Extract the first word of "$tool_basename", so it can be a program name with args.
37689 37689 set dummy $tool_basename; ac_word=$2
37690 37690 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
37691 37691 $as_echo_n "checking for $ac_word... " >&6; }
37692 37692 if ${ac_cv_path_AR+:} false; then :
37693 37693 $as_echo_n "(cached) " >&6
37694 37694 else
37695 37695 case $AR in
37696 37696 [\\/]* | ?:[\\/]*)
37697 37697 ac_cv_path_AR="$AR" # Let the user override the test with a path.
37698 37698 ;;
37699 37699 *)
37700 37700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
37701 37701 for as_dir in $PATH
37702 37702 do
37703 37703 IFS=$as_save_IFS
37704 37704 test -z "$as_dir" && as_dir=.
37705 37705 for ac_exec_ext in '' $ac_executable_extensions; do
37706 37706 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
37707 37707 ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
37708 37708 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
37709 37709 break 2
37710 37710 fi
37711 37711 done
37712 37712 done
37713 37713 IFS=$as_save_IFS
37714 37714
37715 37715 ;;
37716 37716 esac
37717 37717 fi
37718 37718 AR=$ac_cv_path_AR
37719 37719 if test -n "$AR"; then
37720 37720 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
37721 37721 $as_echo "$AR" >&6; }
37722 37722 else
37723 37723 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
37724 37724 $as_echo "no" >&6; }
37725 37725 fi
37726 37726
37727 37727
37728 37728 if test "x$AR" = x; then
37729 37729 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
37730 37730 fi
37731 37731 else
37732 37732 # Otherwise we believe it is a complete path. Use it as it is.
37733 37733 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
37734 37734 $as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
37735 37735 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
37736 37736 $as_echo_n "checking for AR... " >&6; }
37737 37737 if test ! -x "$tool_specified"; then
37738 37738 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
37739 37739 $as_echo "not found" >&6; }
37740 37740 as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
37741 37741 fi
37742 37742 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
37743 37743 $as_echo "$tool_specified" >&6; }
37744 37744 fi
37745 37745 fi
37746 37746 fi
37747 37747
37748 37748 fi
37749 37749
37750 37750
37751 37751 fi
37752 37752
37753 37753 # Only process if variable expands to non-empty
37754 37754
37755 37755 if test "x$AR" != x; then
37756 37756 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37757 37757
37758 37758 # First separate the path from the arguments. This will split at the first
37759 37759 # space.
37760 37760 complete="$AR"
37761 37761 path="${complete%% *}"
37762 37762 tmp="$complete EOL"
37763 37763 arguments="${tmp#* }"
37764 37764
37765 37765 # Input might be given as Windows format, start by converting to
37766 37766 # unix format.
37767 37767 new_path=`$CYGPATH -u "$path"`
37768 37768
37769 37769 # Now try to locate executable using which
37770 37770 new_path=`$WHICH "$new_path" 2> /dev/null`
37771 37771 # bat and cmd files are not always considered executable in cygwin causing which
37772 37772 # to not find them
37773 37773 if test "x$new_path" = x \
37774 37774 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37775 37775 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37776 37776 new_path=`$CYGPATH -u "$path"`
37777 37777 fi
37778 37778 if test "x$new_path" = x; then
37779 37779 # Oops. Which didn't find the executable.
37780 37780 # The splitting of arguments from the executable at a space might have been incorrect,
37781 37781 # since paths with space are more likely in Windows. Give it another try with the whole
37782 37782 # argument.
37783 37783 path="$complete"
37784 37784 arguments="EOL"
37785 37785 new_path=`$CYGPATH -u "$path"`
37786 37786 new_path=`$WHICH "$new_path" 2> /dev/null`
37787 37787 # bat and cmd files are not always considered executable in cygwin causing which
37788 37788 # to not find them
37789 37789 if test "x$new_path" = x \
37790 37790 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37791 37791 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37792 37792 new_path=`$CYGPATH -u "$path"`
37793 37793 fi
37794 37794 if test "x$new_path" = x; then
37795 37795 # It's still not found. Now this is an unrecoverable error.
37796 37796 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
37797 37797 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
37798 37798 has_space=`$ECHO "$complete" | $GREP " "`
37799 37799 if test "x$has_space" != x; then
37800 37800 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37801 37801 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37802 37802 fi
37803 37803 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
37804 37804 fi
37805 37805 fi
37806 37806
37807 37807 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
37808 37808 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
37809 37809 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
37810 37810 # "foo.exe" is OK but "foo" is an error.
37811 37811 #
37812 37812 # This test is therefore slightly more accurate than "test -f" to check for file presence.
37813 37813 # It is also a way to make sure we got the proper file name for the real test later on.
37814 37814 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
37815 37815 if test "x$test_shortpath" = x; then
37816 37816 # Short path failed, file does not exist as specified.
37817 37817 # Try adding .exe or .cmd
37818 37818 if test -f "${new_path}.exe"; then
37819 37819 input_to_shortpath="${new_path}.exe"
37820 37820 elif test -f "${new_path}.cmd"; then
37821 37821 input_to_shortpath="${new_path}.cmd"
37822 37822 else
37823 37823 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
37824 37824 $as_echo "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
37825 37825 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
37826 37826 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
37827 37827 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
37828 37828 fi
37829 37829 else
37830 37830 input_to_shortpath="$new_path"
37831 37831 fi
37832 37832
37833 37833 # Call helper function which possibly converts this using DOS-style short mode.
37834 37834 # If so, the updated path is stored in $new_path.
37835 37835 new_path="$input_to_shortpath"
37836 37836
37837 37837 input_path="$input_to_shortpath"
37838 37838 # Check if we need to convert this using DOS-style short mode. If the path
37839 37839 # contains just simple characters, use it. Otherwise (spaces, weird characters),
37840 37840 # take no chances and rewrite it.
37841 37841 # Note: m4 eats our [], so we need to use [ and ] instead.
37842 37842 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
37843 37843 if test "x$has_forbidden_chars" != x; then
37844 37844 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
37845 37845 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
37846 37846 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
37847 37847 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
37848 37848 # Going to short mode and back again did indeed matter. Since short mode is
37849 37849 # case insensitive, let's make it lowercase to improve readability.
37850 37850 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
37851 37851 # Now convert it back to Unix-style (cygpath)
37852 37852 input_path=`$CYGPATH -u "$shortmode_path"`
37853 37853 new_path="$input_path"
37854 37854 fi
37855 37855 fi
37856 37856
37857 37857 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
37858 37858 if test "x$test_cygdrive_prefix" = x; then
37859 37859 # As a simple fix, exclude /usr/bin since it's not a real path.
37860 37860 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
37861 37861 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
37862 37862 # a path prefixed by /cygdrive for fixpath to work.
37863 37863 new_path="$CYGWIN_ROOT_PATH$input_path"
37864 37864 fi
37865 37865 fi
37866 37866
37867 37867 # remove trailing .exe if any
37868 37868 new_path="${new_path/%.exe/}"
37869 37869
37870 37870 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37871 37871
37872 37872 # First separate the path from the arguments. This will split at the first
37873 37873 # space.
37874 37874 complete="$AR"
37875 37875 path="${complete%% *}"
37876 37876 tmp="$complete EOL"
37877 37877 arguments="${tmp#* }"
37878 37878
37879 37879 # Input might be given as Windows format, start by converting to
37880 37880 # unix format.
37881 37881 new_path="$path"
37882 37882
37883 37883 windows_path="$new_path"
37884 37884 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37885 37885 unix_path=`$CYGPATH -u "$windows_path"`
37886 37886 new_path="$unix_path"
37887 37887 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37888 37888 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37889 37889 new_path="$unix_path"
37890 37890 fi
37891 37891
37892 37892
37893 37893 # Now try to locate executable using which
37894 37894 new_path=`$WHICH "$new_path" 2> /dev/null`
37895 37895
37896 37896 if test "x$new_path" = x; then
37897 37897 # Oops. Which didn't find the executable.
37898 37898 # The splitting of arguments from the executable at a space might have been incorrect,
37899 37899 # since paths with space are more likely in Windows. Give it another try with the whole
37900 37900 # argument.
37901 37901 path="$complete"
37902 37902 arguments="EOL"
37903 37903 new_path="$path"
37904 37904
37905 37905 windows_path="$new_path"
37906 37906 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37907 37907 unix_path=`$CYGPATH -u "$windows_path"`
37908 37908 new_path="$unix_path"
37909 37909 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37910 37910 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37911 37911 new_path="$unix_path"
37912 37912 fi
37913 37913
37914 37914
37915 37915 new_path=`$WHICH "$new_path" 2> /dev/null`
37916 37916 # bat and cmd files are not always considered executable in MSYS causing which
37917 37917 # to not find them
37918 37918 if test "x$new_path" = x \
37919 37919 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
37920 37920 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
37921 37921 new_path="$path"
37922 37922
37923 37923 windows_path="$new_path"
37924 37924 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37925 37925 unix_path=`$CYGPATH -u "$windows_path"`
37926 37926 new_path="$unix_path"
37927 37927 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37928 37928 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37929 37929 new_path="$unix_path"
37930 37930 fi
37931 37931
37932 37932 fi
37933 37933
37934 37934 if test "x$new_path" = x; then
37935 37935 # It's still not found. Now this is an unrecoverable error.
37936 37936 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
37937 37937 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
37938 37938 has_space=`$ECHO "$complete" | $GREP " "`
37939 37939 if test "x$has_space" != x; then
37940 37940 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
37941 37941 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
37942 37942 fi
37943 37943 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
37944 37944 fi
37945 37945 fi
37946 37946
37947 37947 # Now new_path has a complete unix path to the binary
37948 37948 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
37949 37949 # Keep paths in /bin as-is, but remove trailing .exe if any
37950 37950 new_path="${new_path/%.exe/}"
37951 37951 # Do not save /bin paths to all_fixpath_prefixes!
37952 37952 else
37953 37953 # Not in mixed or Windows style, start by that.
37954 37954 new_path=`cmd //c echo $new_path`
37955 37955
37956 37956 input_path="$new_path"
37957 37957 # Check if we need to convert this using DOS-style short mode. If the path
37958 37958 # contains just simple characters, use it. Otherwise (spaces, weird characters),
37959 37959 # take no chances and rewrite it.
37960 37960 # Note: m4 eats our [], so we need to use [ and ] instead.
37961 37961 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
37962 37962 if test "x$has_forbidden_chars" != x; then
37963 37963 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
37964 37964 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
37965 37965 fi
37966 37966
37967 37967 # Output is in $new_path
37968 37968
37969 37969 windows_path="$new_path"
37970 37970 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37971 37971 unix_path=`$CYGPATH -u "$windows_path"`
37972 37972 new_path="$unix_path"
37973 37973 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37974 37974 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37975 37975 new_path="$unix_path"
37976 37976 fi
37977 37977
37978 37978 # remove trailing .exe if any
37979 37979 new_path="${new_path/%.exe/}"
37980 37980
37981 37981 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37982 37982 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37983 37983 fi
37984 37984
37985 37985 else
37986 37986 # We're on a unix platform. Hooray! :)
37987 37987 # First separate the path from the arguments. This will split at the first
37988 37988 # space.
37989 37989 complete="$AR"
37990 37990 path="${complete%% *}"
37991 37991 tmp="$complete EOL"
37992 37992 arguments="${tmp#* }"
37993 37993
37994 37994 # Cannot rely on the command "which" here since it doesn't always work.
37995 37995 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37996 37996 if test -z "$is_absolute_path"; then
37997 37997 # Path to executable is not absolute. Find it.
37998 37998 IFS_save="$IFS"
37999 37999 IFS=:
38000 38000 for p in $PATH; do
38001 38001 if test -f "$p/$path" && test -x "$p/$path"; then
38002 38002 new_path="$p/$path"
38003 38003 break
38004 38004 fi
38005 38005 done
38006 38006 IFS="$IFS_save"
38007 38007 else
38008 38008 # This is an absolute path, we can use it without further modifications.
38009 38009 new_path="$path"
38010 38010 fi
38011 38011
38012 38012 if test "x$new_path" = x; then
38013 38013 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
38014 38014 $as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
38015 38015 has_space=`$ECHO "$complete" | $GREP " "`
38016 38016 if test "x$has_space" != x; then
38017 38017 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
38018 38018 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
38019 38019 fi
38020 38020 as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
38021 38021 fi
38022 38022 fi
38023 38023
38024 38024 # Now join together the path and the arguments once again
38025 38025 if test "x$arguments" != xEOL; then
38026 38026 new_complete="$new_path ${arguments% *}"
38027 38027 else
38028 38028 new_complete="$new_path"
38029 38029 fi
38030 38030
38031 38031 if test "x$complete" != "x$new_complete"; then
38032 38032 AR="$new_complete"
38033 38033 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
38034 38034 $as_echo "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
38035 38035 fi
38036 38036 fi
38037 38037
38038 38038
38039 38039
38040 38040 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
38041 38041
38042 38042
38043 38043 # Publish this variable in the help.
38044 38044
38045 38045
38046 38046 if [ -z "${LIPO+x}" ]; then
38047 38047 # The variable is not set by user, try to locate tool using the code snippet
38048 38048 for ac_prog in lipo
38049 38049 do
38050 38050 # Extract the first word of "$ac_prog", so it can be a program name with args.
38051 38051 set dummy $ac_prog; ac_word=$2
38052 38052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38053 38053 $as_echo_n "checking for $ac_word... " >&6; }
38054 38054 if ${ac_cv_path_LIPO+:} false; then :
38055 38055 $as_echo_n "(cached) " >&6
38056 38056 else
38057 38057 case $LIPO in
38058 38058 [\\/]* | ?:[\\/]*)
38059 38059 ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
38060 38060 ;;
38061 38061 *)
38062 38062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38063 38063 for as_dir in $PATH
38064 38064 do
38065 38065 IFS=$as_save_IFS
38066 38066 test -z "$as_dir" && as_dir=.
38067 38067 for ac_exec_ext in '' $ac_executable_extensions; do
38068 38068 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38069 38069 ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
38070 38070 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38071 38071 break 2
38072 38072 fi
38073 38073 done
38074 38074 done
38075 38075 IFS=$as_save_IFS
38076 38076
38077 38077 ;;
38078 38078 esac
38079 38079 fi
38080 38080 LIPO=$ac_cv_path_LIPO
38081 38081 if test -n "$LIPO"; then
38082 38082 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
38083 38083 $as_echo "$LIPO" >&6; }
38084 38084 else
38085 38085 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38086 38086 $as_echo "no" >&6; }
38087 38087 fi
38088 38088
38089 38089
38090 38090 test -n "$LIPO" && break
38091 38091 done
38092 38092
38093 38093 else
38094 38094 # The variable is set, but is it from the command line or the environment?
38095 38095
38096 38096 # Try to remove the string !LIPO! from our list.
38097 38097 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LIPO!/}
38098 38098 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
38099 38099 # If it failed, the variable was not from the command line. Ignore it,
38100 38100 # but warn the user (except for BASH, which is always set by the calling BASH).
38101 38101 if test "xLIPO" != xBASH; then
38102 38102 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
38103 38103 $as_echo "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
38104 38104 fi
38105 38105 # Try to locate tool using the code snippet
38106 38106 for ac_prog in lipo
38107 38107 do
38108 38108 # Extract the first word of "$ac_prog", so it can be a program name with args.
38109 38109 set dummy $ac_prog; ac_word=$2
38110 38110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38111 38111 $as_echo_n "checking for $ac_word... " >&6; }
38112 38112 if ${ac_cv_path_LIPO+:} false; then :
38113 38113 $as_echo_n "(cached) " >&6
38114 38114 else
38115 38115 case $LIPO in
38116 38116 [\\/]* | ?:[\\/]*)
38117 38117 ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
38118 38118 ;;
38119 38119 *)
38120 38120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38121 38121 for as_dir in $PATH
38122 38122 do
38123 38123 IFS=$as_save_IFS
38124 38124 test -z "$as_dir" && as_dir=.
38125 38125 for ac_exec_ext in '' $ac_executable_extensions; do
38126 38126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38127 38127 ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
38128 38128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38129 38129 break 2
38130 38130 fi
38131 38131 done
38132 38132 done
38133 38133 IFS=$as_save_IFS
38134 38134
38135 38135 ;;
38136 38136 esac
38137 38137 fi
38138 38138 LIPO=$ac_cv_path_LIPO
38139 38139 if test -n "$LIPO"; then
38140 38140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
38141 38141 $as_echo "$LIPO" >&6; }
38142 38142 else
38143 38143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38144 38144 $as_echo "no" >&6; }
38145 38145 fi
38146 38146
38147 38147
38148 38148 test -n "$LIPO" && break
38149 38149 done
38150 38150
38151 38151 else
38152 38152 # If it succeeded, then it was overridden by the user. We will use it
38153 38153 # for the tool.
38154 38154
38155 38155 # First remove it from the list of overridden variables, so we can test
38156 38156 # for unknown variables in the end.
38157 38157 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
38158 38158
38159 38159 # Check if we try to supply an empty value
38160 38160 if test "x$LIPO" = x; then
38161 38161 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LIPO= (no value)" >&5
38162 38162 $as_echo "$as_me: Setting user supplied tool LIPO= (no value)" >&6;}
38163 38163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
38164 38164 $as_echo_n "checking for LIPO... " >&6; }
38165 38165 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
38166 38166 $as_echo "disabled" >&6; }
38167 38167 else
38168 38168 # Check if the provided tool contains a complete path.
38169 38169 tool_specified="$LIPO"
38170 38170 tool_basename="${tool_specified##*/}"
38171 38171 if test "x$tool_basename" = "x$tool_specified"; then
38172 38172 # A command without a complete path is provided, search $PATH.
38173 38173 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
38174 38174 $as_echo "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
38175 38175 # Extract the first word of "$tool_basename", so it can be a program name with args.
38176 38176 set dummy $tool_basename; ac_word=$2
38177 38177 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38178 38178 $as_echo_n "checking for $ac_word... " >&6; }
38179 38179 if ${ac_cv_path_LIPO+:} false; then :
38180 38180 $as_echo_n "(cached) " >&6
38181 38181 else
38182 38182 case $LIPO in
38183 38183 [\\/]* | ?:[\\/]*)
38184 38184 ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
38185 38185 ;;
38186 38186 *)
38187 38187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38188 38188 for as_dir in $PATH
38189 38189 do
38190 38190 IFS=$as_save_IFS
38191 38191 test -z "$as_dir" && as_dir=.
38192 38192 for ac_exec_ext in '' $ac_executable_extensions; do
38193 38193 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38194 38194 ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
38195 38195 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38196 38196 break 2
38197 38197 fi
38198 38198 done
38199 38199 done
38200 38200 IFS=$as_save_IFS
38201 38201
38202 38202 ;;
38203 38203 esac
38204 38204 fi
38205 38205 LIPO=$ac_cv_path_LIPO
38206 38206 if test -n "$LIPO"; then
38207 38207 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
38208 38208 $as_echo "$LIPO" >&6; }
38209 38209 else
38210 38210 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38211 38211 $as_echo "no" >&6; }
38212 38212 fi
38213 38213
38214 38214
38215 38215 if test "x$LIPO" = x; then
38216 38216 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
38217 38217 fi
38218 38218 else
38219 38219 # Otherwise we believe it is a complete path. Use it as it is.
38220 38220 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
38221 38221 $as_echo "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
38222 38222 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
38223 38223 $as_echo_n "checking for LIPO... " >&6; }
38224 38224 if test ! -x "$tool_specified"; then
38225 38225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
38226 38226 $as_echo "not found" >&6; }
38227 38227 as_fn_error $? "User supplied tool LIPO=$tool_specified does not exist or is not executable" "$LINENO" 5
38228 38228 fi
38229 38229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
38230 38230 $as_echo "$tool_specified" >&6; }
38231 38231 fi
38232 38232 fi
38233 38233 fi
38234 38234
38235 38235 fi
38236 38236
38237 38237
38238 38238
38239 38239 # Only process if variable expands to non-empty
38240 38240
38241 38241 if test "x$LIPO" != x; then
38242 38242 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38243 38243
38244 38244 # First separate the path from the arguments. This will split at the first
38245 38245 # space.
38246 38246 complete="$LIPO"
38247 38247 path="${complete%% *}"
38248 38248 tmp="$complete EOL"
38249 38249 arguments="${tmp#* }"
38250 38250
38251 38251 # Input might be given as Windows format, start by converting to
38252 38252 # unix format.
38253 38253 new_path=`$CYGPATH -u "$path"`
38254 38254
38255 38255 # Now try to locate executable using which
38256 38256 new_path=`$WHICH "$new_path" 2> /dev/null`
38257 38257 # bat and cmd files are not always considered executable in cygwin causing which
38258 38258 # to not find them
38259 38259 if test "x$new_path" = x \
38260 38260 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38261 38261 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38262 38262 new_path=`$CYGPATH -u "$path"`
38263 38263 fi
38264 38264 if test "x$new_path" = x; then
38265 38265 # Oops. Which didn't find the executable.
38266 38266 # The splitting of arguments from the executable at a space might have been incorrect,
38267 38267 # since paths with space are more likely in Windows. Give it another try with the whole
38268 38268 # argument.
38269 38269 path="$complete"
38270 38270 arguments="EOL"
38271 38271 new_path=`$CYGPATH -u "$path"`
38272 38272 new_path=`$WHICH "$new_path" 2> /dev/null`
38273 38273 # bat and cmd files are not always considered executable in cygwin causing which
38274 38274 # to not find them
38275 38275 if test "x$new_path" = x \
38276 38276 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38277 38277 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38278 38278 new_path=`$CYGPATH -u "$path"`
38279 38279 fi
38280 38280 if test "x$new_path" = x; then
38281 38281 # It's still not found. Now this is an unrecoverable error.
38282 38282 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
38283 38283 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
38284 38284 has_space=`$ECHO "$complete" | $GREP " "`
38285 38285 if test "x$has_space" != x; then
38286 38286 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38287 38287 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38288 38288 fi
38289 38289 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
38290 38290 fi
38291 38291 fi
38292 38292
38293 38293 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
38294 38294 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
38295 38295 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
38296 38296 # "foo.exe" is OK but "foo" is an error.
38297 38297 #
38298 38298 # This test is therefore slightly more accurate than "test -f" to check for file presence.
38299 38299 # It is also a way to make sure we got the proper file name for the real test later on.
38300 38300 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
38301 38301 if test "x$test_shortpath" = x; then
38302 38302 # Short path failed, file does not exist as specified.
38303 38303 # Try adding .exe or .cmd
38304 38304 if test -f "${new_path}.exe"; then
38305 38305 input_to_shortpath="${new_path}.exe"
38306 38306 elif test -f "${new_path}.cmd"; then
38307 38307 input_to_shortpath="${new_path}.cmd"
38308 38308 else
38309 38309 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
38310 38310 $as_echo "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
38311 38311 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
38312 38312 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
38313 38313 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
38314 38314 fi
38315 38315 else
38316 38316 input_to_shortpath="$new_path"
38317 38317 fi
38318 38318
38319 38319 # Call helper function which possibly converts this using DOS-style short mode.
38320 38320 # If so, the updated path is stored in $new_path.
38321 38321 new_path="$input_to_shortpath"
38322 38322
38323 38323 input_path="$input_to_shortpath"
38324 38324 # Check if we need to convert this using DOS-style short mode. If the path
38325 38325 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38326 38326 # take no chances and rewrite it.
38327 38327 # Note: m4 eats our [], so we need to use [ and ] instead.
38328 38328 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38329 38329 if test "x$has_forbidden_chars" != x; then
38330 38330 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38331 38331 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38332 38332 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38333 38333 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38334 38334 # Going to short mode and back again did indeed matter. Since short mode is
38335 38335 # case insensitive, let's make it lowercase to improve readability.
38336 38336 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38337 38337 # Now convert it back to Unix-style (cygpath)
38338 38338 input_path=`$CYGPATH -u "$shortmode_path"`
38339 38339 new_path="$input_path"
38340 38340 fi
38341 38341 fi
38342 38342
38343 38343 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38344 38344 if test "x$test_cygdrive_prefix" = x; then
38345 38345 # As a simple fix, exclude /usr/bin since it's not a real path.
38346 38346 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38347 38347 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38348 38348 # a path prefixed by /cygdrive for fixpath to work.
38349 38349 new_path="$CYGWIN_ROOT_PATH$input_path"
38350 38350 fi
38351 38351 fi
38352 38352
38353 38353 # remove trailing .exe if any
38354 38354 new_path="${new_path/%.exe/}"
38355 38355
38356 38356 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38357 38357
38358 38358 # First separate the path from the arguments. This will split at the first
38359 38359 # space.
38360 38360 complete="$LIPO"
38361 38361 path="${complete%% *}"
38362 38362 tmp="$complete EOL"
38363 38363 arguments="${tmp#* }"
38364 38364
38365 38365 # Input might be given as Windows format, start by converting to
38366 38366 # unix format.
38367 38367 new_path="$path"
38368 38368
38369 38369 windows_path="$new_path"
38370 38370 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38371 38371 unix_path=`$CYGPATH -u "$windows_path"`
38372 38372 new_path="$unix_path"
38373 38373 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38374 38374 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38375 38375 new_path="$unix_path"
38376 38376 fi
38377 38377
38378 38378
38379 38379 # Now try to locate executable using which
38380 38380 new_path=`$WHICH "$new_path" 2> /dev/null`
38381 38381
38382 38382 if test "x$new_path" = x; then
38383 38383 # Oops. Which didn't find the executable.
38384 38384 # The splitting of arguments from the executable at a space might have been incorrect,
38385 38385 # since paths with space are more likely in Windows. Give it another try with the whole
38386 38386 # argument.
38387 38387 path="$complete"
38388 38388 arguments="EOL"
38389 38389 new_path="$path"
38390 38390
38391 38391 windows_path="$new_path"
38392 38392 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38393 38393 unix_path=`$CYGPATH -u "$windows_path"`
38394 38394 new_path="$unix_path"
38395 38395 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38396 38396 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38397 38397 new_path="$unix_path"
38398 38398 fi
38399 38399
38400 38400
38401 38401 new_path=`$WHICH "$new_path" 2> /dev/null`
38402 38402 # bat and cmd files are not always considered executable in MSYS causing which
38403 38403 # to not find them
38404 38404 if test "x$new_path" = x \
38405 38405 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38406 38406 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38407 38407 new_path="$path"
38408 38408
38409 38409 windows_path="$new_path"
38410 38410 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38411 38411 unix_path=`$CYGPATH -u "$windows_path"`
38412 38412 new_path="$unix_path"
38413 38413 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38414 38414 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38415 38415 new_path="$unix_path"
38416 38416 fi
38417 38417
38418 38418 fi
38419 38419
38420 38420 if test "x$new_path" = x; then
38421 38421 # It's still not found. Now this is an unrecoverable error.
38422 38422 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
38423 38423 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
38424 38424 has_space=`$ECHO "$complete" | $GREP " "`
38425 38425 if test "x$has_space" != x; then
38426 38426 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38427 38427 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38428 38428 fi
38429 38429 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
38430 38430 fi
38431 38431 fi
38432 38432
38433 38433 # Now new_path has a complete unix path to the binary
38434 38434 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38435 38435 # Keep paths in /bin as-is, but remove trailing .exe if any
38436 38436 new_path="${new_path/%.exe/}"
38437 38437 # Do not save /bin paths to all_fixpath_prefixes!
38438 38438 else
38439 38439 # Not in mixed or Windows style, start by that.
38440 38440 new_path=`cmd //c echo $new_path`
38441 38441
38442 38442 input_path="$new_path"
38443 38443 # Check if we need to convert this using DOS-style short mode. If the path
38444 38444 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38445 38445 # take no chances and rewrite it.
38446 38446 # Note: m4 eats our [], so we need to use [ and ] instead.
38447 38447 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
38448 38448 if test "x$has_forbidden_chars" != x; then
38449 38449 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38450 38450 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38451 38451 fi
38452 38452
38453 38453 # Output is in $new_path
38454 38454
38455 38455 windows_path="$new_path"
38456 38456 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38457 38457 unix_path=`$CYGPATH -u "$windows_path"`
38458 38458 new_path="$unix_path"
38459 38459 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38460 38460 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38461 38461 new_path="$unix_path"
38462 38462 fi
38463 38463
38464 38464 # remove trailing .exe if any
38465 38465 new_path="${new_path/%.exe/}"
38466 38466
38467 38467 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38468 38468 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38469 38469 fi
38470 38470
38471 38471 else
38472 38472 # We're on a unix platform. Hooray! :)
38473 38473 # First separate the path from the arguments. This will split at the first
38474 38474 # space.
38475 38475 complete="$LIPO"
38476 38476 path="${complete%% *}"
38477 38477 tmp="$complete EOL"
38478 38478 arguments="${tmp#* }"
38479 38479
38480 38480 # Cannot rely on the command "which" here since it doesn't always work.
38481 38481 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38482 38482 if test -z "$is_absolute_path"; then
38483 38483 # Path to executable is not absolute. Find it.
38484 38484 IFS_save="$IFS"
38485 38485 IFS=:
38486 38486 for p in $PATH; do
38487 38487 if test -f "$p/$path" && test -x "$p/$path"; then
38488 38488 new_path="$p/$path"
38489 38489 break
38490 38490 fi
38491 38491 done
38492 38492 IFS="$IFS_save"
38493 38493 else
38494 38494 # This is an absolute path, we can use it without further modifications.
38495 38495 new_path="$path"
38496 38496 fi
38497 38497
38498 38498 if test "x$new_path" = x; then
38499 38499 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
38500 38500 $as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
38501 38501 has_space=`$ECHO "$complete" | $GREP " "`
38502 38502 if test "x$has_space" != x; then
38503 38503 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
38504 38504 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
38505 38505 fi
38506 38506 as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
38507 38507 fi
38508 38508 fi
38509 38509
38510 38510 # Now join together the path and the arguments once again
38511 38511 if test "x$arguments" != xEOL; then
38512 38512 new_complete="$new_path ${arguments% *}"
38513 38513 else
38514 38514 new_complete="$new_path"
38515 38515 fi
38516 38516
38517 38517 if test "x$complete" != "x$new_complete"; then
38518 38518 LIPO="$new_complete"
38519 38519 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
38520 38520 $as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
38521 38521 fi
38522 38522 fi
38523 38523
38524 38524 fi
38525 38525
38526 38526 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
38527 38527 # Extract the first word of "mt", so it can be a program name with args.
38528 38528 set dummy mt; ac_word=$2
38529 38529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38530 38530 $as_echo_n "checking for $ac_word... " >&6; }
38531 38531 if ${ac_cv_prog_MT+:} false; then :
38532 38532 $as_echo_n "(cached) " >&6
38533 38533 else
38534 38534 if test -n "$MT"; then
38535 38535 ac_cv_prog_MT="$MT" # Let the user override the test.
38536 38536 else
38537 38537 ac_prog_rejected=no
38538 38538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38539 38539 for as_dir in $PATH
38540 38540 do
38541 38541 IFS=$as_save_IFS
38542 38542 test -z "$as_dir" && as_dir=.
38543 38543 for ac_exec_ext in '' $ac_executable_extensions; do
38544 38544 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38545 38545 if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
38546 38546 ac_prog_rejected=yes
38547 38547 continue
38548 38548 fi
38549 38549 ac_cv_prog_MT="mt"
38550 38550 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38551 38551 break 2
38552 38552 fi
38553 38553 done
38554 38554 done
38555 38555 IFS=$as_save_IFS
38556 38556
38557 38557 if test $ac_prog_rejected = yes; then
38558 38558 # We found a bogon in the path, so make sure we never use it.
38559 38559 set dummy $ac_cv_prog_MT
38560 38560 shift
38561 38561 if test $# != 0; then
38562 38562 # We chose a different compiler from the bogus one.
38563 38563 # However, it has the same basename, so the bogon will be chosen
38564 38564 # first if we set MT to just the basename; use the full file name.
38565 38565 shift
38566 38566 ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@"
38567 38567 fi
38568 38568 fi
38569 38569 fi
38570 38570 fi
38571 38571 MT=$ac_cv_prog_MT
38572 38572 if test -n "$MT"; then
38573 38573 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
38574 38574 $as_echo "$MT" >&6; }
38575 38575 else
38576 38576 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38577 38577 $as_echo "no" >&6; }
38578 38578 fi
38579 38579
38580 38580
38581 38581
38582 38582 # Only process if variable expands to non-empty
38583 38583
38584 38584 if test "x$MT" != x; then
38585 38585 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38586 38586
38587 38587 # First separate the path from the arguments. This will split at the first
38588 38588 # space.
38589 38589 complete="$MT"
38590 38590 path="${complete%% *}"
38591 38591 tmp="$complete EOL"
38592 38592 arguments="${tmp#* }"
38593 38593
38594 38594 # Input might be given as Windows format, start by converting to
38595 38595 # unix format.
38596 38596 new_path=`$CYGPATH -u "$path"`
38597 38597
38598 38598 # Now try to locate executable using which
38599 38599 new_path=`$WHICH "$new_path" 2> /dev/null`
38600 38600 # bat and cmd files are not always considered executable in cygwin causing which
38601 38601 # to not find them
38602 38602 if test "x$new_path" = x \
38603 38603 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38604 38604 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38605 38605 new_path=`$CYGPATH -u "$path"`
38606 38606 fi
38607 38607 if test "x$new_path" = x; then
38608 38608 # Oops. Which didn't find the executable.
38609 38609 # The splitting of arguments from the executable at a space might have been incorrect,
38610 38610 # since paths with space are more likely in Windows. Give it another try with the whole
38611 38611 # argument.
38612 38612 path="$complete"
38613 38613 arguments="EOL"
38614 38614 new_path=`$CYGPATH -u "$path"`
38615 38615 new_path=`$WHICH "$new_path" 2> /dev/null`
38616 38616 # bat and cmd files are not always considered executable in cygwin causing which
38617 38617 # to not find them
38618 38618 if test "x$new_path" = x \
38619 38619 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38620 38620 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38621 38621 new_path=`$CYGPATH -u "$path"`
38622 38622 fi
38623 38623 if test "x$new_path" = x; then
38624 38624 # It's still not found. Now this is an unrecoverable error.
38625 38625 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
38626 38626 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
38627 38627 has_space=`$ECHO "$complete" | $GREP " "`
38628 38628 if test "x$has_space" != x; then
38629 38629 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38630 38630 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38631 38631 fi
38632 38632 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
38633 38633 fi
38634 38634 fi
38635 38635
38636 38636 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
38637 38637 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
38638 38638 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
38639 38639 # "foo.exe" is OK but "foo" is an error.
38640 38640 #
38641 38641 # This test is therefore slightly more accurate than "test -f" to check for file presence.
38642 38642 # It is also a way to make sure we got the proper file name for the real test later on.
38643 38643 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
38644 38644 if test "x$test_shortpath" = x; then
38645 38645 # Short path failed, file does not exist as specified.
38646 38646 # Try adding .exe or .cmd
38647 38647 if test -f "${new_path}.exe"; then
38648 38648 input_to_shortpath="${new_path}.exe"
38649 38649 elif test -f "${new_path}.cmd"; then
38650 38650 input_to_shortpath="${new_path}.cmd"
38651 38651 else
38652 38652 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
38653 38653 $as_echo "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
38654 38654 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
38655 38655 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
38656 38656 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
38657 38657 fi
38658 38658 else
38659 38659 input_to_shortpath="$new_path"
38660 38660 fi
38661 38661
38662 38662 # Call helper function which possibly converts this using DOS-style short mode.
38663 38663 # If so, the updated path is stored in $new_path.
38664 38664 new_path="$input_to_shortpath"
38665 38665
38666 38666 input_path="$input_to_shortpath"
38667 38667 # Check if we need to convert this using DOS-style short mode. If the path
38668 38668 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38669 38669 # take no chances and rewrite it.
38670 38670 # Note: m4 eats our [], so we need to use [ and ] instead.
38671 38671 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38672 38672 if test "x$has_forbidden_chars" != x; then
38673 38673 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38674 38674 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38675 38675 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38676 38676 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38677 38677 # Going to short mode and back again did indeed matter. Since short mode is
38678 38678 # case insensitive, let's make it lowercase to improve readability.
38679 38679 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38680 38680 # Now convert it back to Unix-style (cygpath)
38681 38681 input_path=`$CYGPATH -u "$shortmode_path"`
38682 38682 new_path="$input_path"
38683 38683 fi
38684 38684 fi
38685 38685
38686 38686 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38687 38687 if test "x$test_cygdrive_prefix" = x; then
38688 38688 # As a simple fix, exclude /usr/bin since it's not a real path.
38689 38689 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38690 38690 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38691 38691 # a path prefixed by /cygdrive for fixpath to work.
38692 38692 new_path="$CYGWIN_ROOT_PATH$input_path"
38693 38693 fi
38694 38694 fi
38695 38695
38696 38696 # remove trailing .exe if any
38697 38697 new_path="${new_path/%.exe/}"
38698 38698
38699 38699 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38700 38700
38701 38701 # First separate the path from the arguments. This will split at the first
38702 38702 # space.
38703 38703 complete="$MT"
38704 38704 path="${complete%% *}"
38705 38705 tmp="$complete EOL"
38706 38706 arguments="${tmp#* }"
38707 38707
38708 38708 # Input might be given as Windows format, start by converting to
38709 38709 # unix format.
38710 38710 new_path="$path"
38711 38711
38712 38712 windows_path="$new_path"
38713 38713 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38714 38714 unix_path=`$CYGPATH -u "$windows_path"`
38715 38715 new_path="$unix_path"
38716 38716 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38717 38717 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38718 38718 new_path="$unix_path"
38719 38719 fi
38720 38720
38721 38721
38722 38722 # Now try to locate executable using which
38723 38723 new_path=`$WHICH "$new_path" 2> /dev/null`
38724 38724
38725 38725 if test "x$new_path" = x; then
38726 38726 # Oops. Which didn't find the executable.
38727 38727 # The splitting of arguments from the executable at a space might have been incorrect,
38728 38728 # since paths with space are more likely in Windows. Give it another try with the whole
38729 38729 # argument.
38730 38730 path="$complete"
38731 38731 arguments="EOL"
38732 38732 new_path="$path"
38733 38733
38734 38734 windows_path="$new_path"
38735 38735 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38736 38736 unix_path=`$CYGPATH -u "$windows_path"`
38737 38737 new_path="$unix_path"
38738 38738 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38739 38739 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38740 38740 new_path="$unix_path"
38741 38741 fi
38742 38742
38743 38743
38744 38744 new_path=`$WHICH "$new_path" 2> /dev/null`
38745 38745 # bat and cmd files are not always considered executable in MSYS causing which
38746 38746 # to not find them
38747 38747 if test "x$new_path" = x \
38748 38748 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38749 38749 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38750 38750 new_path="$path"
38751 38751
38752 38752 windows_path="$new_path"
38753 38753 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38754 38754 unix_path=`$CYGPATH -u "$windows_path"`
38755 38755 new_path="$unix_path"
38756 38756 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38757 38757 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38758 38758 new_path="$unix_path"
38759 38759 fi
38760 38760
38761 38761 fi
38762 38762
38763 38763 if test "x$new_path" = x; then
38764 38764 # It's still not found. Now this is an unrecoverable error.
38765 38765 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
38766 38766 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
38767 38767 has_space=`$ECHO "$complete" | $GREP " "`
38768 38768 if test "x$has_space" != x; then
38769 38769 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38770 38770 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38771 38771 fi
38772 38772 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
38773 38773 fi
38774 38774 fi
38775 38775
38776 38776 # Now new_path has a complete unix path to the binary
38777 38777 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
38778 38778 # Keep paths in /bin as-is, but remove trailing .exe if any
38779 38779 new_path="${new_path/%.exe/}"
38780 38780 # Do not save /bin paths to all_fixpath_prefixes!
38781 38781 else
38782 38782 # Not in mixed or Windows style, start by that.
38783 38783 new_path=`cmd //c echo $new_path`
38784 38784
38785 38785 input_path="$new_path"
38786 38786 # Check if we need to convert this using DOS-style short mode. If the path
38787 38787 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38788 38788 # take no chances and rewrite it.
38789 38789 # Note: m4 eats our [], so we need to use [ and ] instead.
38790 38790 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
38791 38791 if test "x$has_forbidden_chars" != x; then
38792 38792 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38793 38793 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38794 38794 fi
38795 38795
38796 38796 # Output is in $new_path
38797 38797
38798 38798 windows_path="$new_path"
38799 38799 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38800 38800 unix_path=`$CYGPATH -u "$windows_path"`
38801 38801 new_path="$unix_path"
38802 38802 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38803 38803 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38804 38804 new_path="$unix_path"
38805 38805 fi
38806 38806
38807 38807 # remove trailing .exe if any
38808 38808 new_path="${new_path/%.exe/}"
38809 38809
38810 38810 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38811 38811 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38812 38812 fi
38813 38813
38814 38814 else
38815 38815 # We're on a unix platform. Hooray! :)
38816 38816 # First separate the path from the arguments. This will split at the first
38817 38817 # space.
38818 38818 complete="$MT"
38819 38819 path="${complete%% *}"
38820 38820 tmp="$complete EOL"
38821 38821 arguments="${tmp#* }"
38822 38822
38823 38823 # Cannot rely on the command "which" here since it doesn't always work.
38824 38824 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38825 38825 if test -z "$is_absolute_path"; then
38826 38826 # Path to executable is not absolute. Find it.
38827 38827 IFS_save="$IFS"
38828 38828 IFS=:
38829 38829 for p in $PATH; do
38830 38830 if test -f "$p/$path" && test -x "$p/$path"; then
38831 38831 new_path="$p/$path"
38832 38832 break
38833 38833 fi
38834 38834 done
38835 38835 IFS="$IFS_save"
38836 38836 else
38837 38837 # This is an absolute path, we can use it without further modifications.
38838 38838 new_path="$path"
38839 38839 fi
38840 38840
38841 38841 if test "x$new_path" = x; then
38842 38842 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
38843 38843 $as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
38844 38844 has_space=`$ECHO "$complete" | $GREP " "`
38845 38845 if test "x$has_space" != x; then
38846 38846 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
38847 38847 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
38848 38848 fi
38849 38849 as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
38850 38850 fi
38851 38851 fi
38852 38852
38853 38853 # Now join together the path and the arguments once again
38854 38854 if test "x$arguments" != xEOL; then
38855 38855 new_complete="$new_path ${arguments% *}"
38856 38856 else
38857 38857 new_complete="$new_path"
38858 38858 fi
38859 38859
38860 38860 if test "x$complete" != "x$new_complete"; then
38861 38861 MT="$new_complete"
38862 38862 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
38863 38863 $as_echo "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
38864 38864 fi
38865 38865 fi
38866 38866
38867 38867 # Setup the resource compiler (RC)
38868 38868 # Extract the first word of "rc", so it can be a program name with args.
38869 38869 set dummy rc; ac_word=$2
38870 38870 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
38871 38871 $as_echo_n "checking for $ac_word... " >&6; }
38872 38872 if ${ac_cv_prog_RC+:} false; then :
38873 38873 $as_echo_n "(cached) " >&6
38874 38874 else
38875 38875 if test -n "$RC"; then
38876 38876 ac_cv_prog_RC="$RC" # Let the user override the test.
38877 38877 else
38878 38878 ac_prog_rejected=no
38879 38879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
38880 38880 for as_dir in $PATH
38881 38881 do
38882 38882 IFS=$as_save_IFS
38883 38883 test -z "$as_dir" && as_dir=.
38884 38884 for ac_exec_ext in '' $ac_executable_extensions; do
38885 38885 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
38886 38886 if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
38887 38887 ac_prog_rejected=yes
38888 38888 continue
38889 38889 fi
38890 38890 ac_cv_prog_RC="rc"
38891 38891 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
38892 38892 break 2
38893 38893 fi
38894 38894 done
38895 38895 done
38896 38896 IFS=$as_save_IFS
38897 38897
38898 38898 if test $ac_prog_rejected = yes; then
38899 38899 # We found a bogon in the path, so make sure we never use it.
38900 38900 set dummy $ac_cv_prog_RC
38901 38901 shift
38902 38902 if test $# != 0; then
38903 38903 # We chose a different compiler from the bogus one.
38904 38904 # However, it has the same basename, so the bogon will be chosen
38905 38905 # first if we set RC to just the basename; use the full file name.
38906 38906 shift
38907 38907 ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@"
38908 38908 fi
38909 38909 fi
38910 38910 fi
38911 38911 fi
38912 38912 RC=$ac_cv_prog_RC
38913 38913 if test -n "$RC"; then
38914 38914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
38915 38915 $as_echo "$RC" >&6; }
38916 38916 else
38917 38917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
38918 38918 $as_echo "no" >&6; }
38919 38919 fi
38920 38920
38921 38921
38922 38922
38923 38923 # Only process if variable expands to non-empty
38924 38924
38925 38925 if test "x$RC" != x; then
38926 38926 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38927 38927
38928 38928 # First separate the path from the arguments. This will split at the first
38929 38929 # space.
38930 38930 complete="$RC"
38931 38931 path="${complete%% *}"
38932 38932 tmp="$complete EOL"
38933 38933 arguments="${tmp#* }"
38934 38934
38935 38935 # Input might be given as Windows format, start by converting to
38936 38936 # unix format.
38937 38937 new_path=`$CYGPATH -u "$path"`
38938 38938
38939 38939 # Now try to locate executable using which
38940 38940 new_path=`$WHICH "$new_path" 2> /dev/null`
38941 38941 # bat and cmd files are not always considered executable in cygwin causing which
38942 38942 # to not find them
38943 38943 if test "x$new_path" = x \
38944 38944 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38945 38945 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38946 38946 new_path=`$CYGPATH -u "$path"`
38947 38947 fi
38948 38948 if test "x$new_path" = x; then
38949 38949 # Oops. Which didn't find the executable.
38950 38950 # The splitting of arguments from the executable at a space might have been incorrect,
38951 38951 # since paths with space are more likely in Windows. Give it another try with the whole
38952 38952 # argument.
38953 38953 path="$complete"
38954 38954 arguments="EOL"
38955 38955 new_path=`$CYGPATH -u "$path"`
38956 38956 new_path=`$WHICH "$new_path" 2> /dev/null`
38957 38957 # bat and cmd files are not always considered executable in cygwin causing which
38958 38958 # to not find them
38959 38959 if test "x$new_path" = x \
38960 38960 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
38961 38961 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
38962 38962 new_path=`$CYGPATH -u "$path"`
38963 38963 fi
38964 38964 if test "x$new_path" = x; then
38965 38965 # It's still not found. Now this is an unrecoverable error.
38966 38966 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
38967 38967 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
38968 38968 has_space=`$ECHO "$complete" | $GREP " "`
38969 38969 if test "x$has_space" != x; then
38970 38970 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
38971 38971 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
38972 38972 fi
38973 38973 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
38974 38974 fi
38975 38975 fi
38976 38976
38977 38977 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
38978 38978 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
38979 38979 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
38980 38980 # "foo.exe" is OK but "foo" is an error.
38981 38981 #
38982 38982 # This test is therefore slightly more accurate than "test -f" to check for file presence.
38983 38983 # It is also a way to make sure we got the proper file name for the real test later on.
38984 38984 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
38985 38985 if test "x$test_shortpath" = x; then
38986 38986 # Short path failed, file does not exist as specified.
38987 38987 # Try adding .exe or .cmd
38988 38988 if test -f "${new_path}.exe"; then
38989 38989 input_to_shortpath="${new_path}.exe"
38990 38990 elif test -f "${new_path}.cmd"; then
38991 38991 input_to_shortpath="${new_path}.cmd"
38992 38992 else
38993 38993 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
38994 38994 $as_echo "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
38995 38995 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
38996 38996 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
38997 38997 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
38998 38998 fi
38999 38999 else
39000 39000 input_to_shortpath="$new_path"
39001 39001 fi
39002 39002
39003 39003 # Call helper function which possibly converts this using DOS-style short mode.
39004 39004 # If so, the updated path is stored in $new_path.
39005 39005 new_path="$input_to_shortpath"
39006 39006
39007 39007 input_path="$input_to_shortpath"
39008 39008 # Check if we need to convert this using DOS-style short mode. If the path
39009 39009 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39010 39010 # take no chances and rewrite it.
39011 39011 # Note: m4 eats our [], so we need to use [ and ] instead.
39012 39012 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39013 39013 if test "x$has_forbidden_chars" != x; then
39014 39014 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39015 39015 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39016 39016 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39017 39017 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39018 39018 # Going to short mode and back again did indeed matter. Since short mode is
39019 39019 # case insensitive, let's make it lowercase to improve readability.
39020 39020 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39021 39021 # Now convert it back to Unix-style (cygpath)
39022 39022 input_path=`$CYGPATH -u "$shortmode_path"`
39023 39023 new_path="$input_path"
39024 39024 fi
39025 39025 fi
39026 39026
39027 39027 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39028 39028 if test "x$test_cygdrive_prefix" = x; then
39029 39029 # As a simple fix, exclude /usr/bin since it's not a real path.
39030 39030 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39031 39031 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39032 39032 # a path prefixed by /cygdrive for fixpath to work.
39033 39033 new_path="$CYGWIN_ROOT_PATH$input_path"
39034 39034 fi
39035 39035 fi
39036 39036
39037 39037 # remove trailing .exe if any
39038 39038 new_path="${new_path/%.exe/}"
39039 39039
39040 39040 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39041 39041
39042 39042 # First separate the path from the arguments. This will split at the first
39043 39043 # space.
39044 39044 complete="$RC"
39045 39045 path="${complete%% *}"
39046 39046 tmp="$complete EOL"
39047 39047 arguments="${tmp#* }"
39048 39048
39049 39049 # Input might be given as Windows format, start by converting to
39050 39050 # unix format.
39051 39051 new_path="$path"
39052 39052
39053 39053 windows_path="$new_path"
39054 39054 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39055 39055 unix_path=`$CYGPATH -u "$windows_path"`
39056 39056 new_path="$unix_path"
39057 39057 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39058 39058 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39059 39059 new_path="$unix_path"
39060 39060 fi
39061 39061
39062 39062
39063 39063 # Now try to locate executable using which
39064 39064 new_path=`$WHICH "$new_path" 2> /dev/null`
39065 39065
39066 39066 if test "x$new_path" = x; then
39067 39067 # Oops. Which didn't find the executable.
39068 39068 # The splitting of arguments from the executable at a space might have been incorrect,
39069 39069 # since paths with space are more likely in Windows. Give it another try with the whole
39070 39070 # argument.
39071 39071 path="$complete"
39072 39072 arguments="EOL"
39073 39073 new_path="$path"
39074 39074
39075 39075 windows_path="$new_path"
39076 39076 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39077 39077 unix_path=`$CYGPATH -u "$windows_path"`
39078 39078 new_path="$unix_path"
39079 39079 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39080 39080 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39081 39081 new_path="$unix_path"
39082 39082 fi
39083 39083
39084 39084
39085 39085 new_path=`$WHICH "$new_path" 2> /dev/null`
39086 39086 # bat and cmd files are not always considered executable in MSYS causing which
39087 39087 # to not find them
39088 39088 if test "x$new_path" = x \
39089 39089 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39090 39090 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39091 39091 new_path="$path"
39092 39092
39093 39093 windows_path="$new_path"
39094 39094 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39095 39095 unix_path=`$CYGPATH -u "$windows_path"`
39096 39096 new_path="$unix_path"
39097 39097 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39098 39098 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39099 39099 new_path="$unix_path"
39100 39100 fi
39101 39101
39102 39102 fi
39103 39103
39104 39104 if test "x$new_path" = x; then
39105 39105 # It's still not found. Now this is an unrecoverable error.
39106 39106 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
39107 39107 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
39108 39108 has_space=`$ECHO "$complete" | $GREP " "`
39109 39109 if test "x$has_space" != x; then
39110 39110 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39111 39111 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39112 39112 fi
39113 39113 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
39114 39114 fi
39115 39115 fi
39116 39116
39117 39117 # Now new_path has a complete unix path to the binary
39118 39118 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39119 39119 # Keep paths in /bin as-is, but remove trailing .exe if any
39120 39120 new_path="${new_path/%.exe/}"
39121 39121 # Do not save /bin paths to all_fixpath_prefixes!
39122 39122 else
39123 39123 # Not in mixed or Windows style, start by that.
39124 39124 new_path=`cmd //c echo $new_path`
39125 39125
39126 39126 input_path="$new_path"
39127 39127 # Check if we need to convert this using DOS-style short mode. If the path
39128 39128 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39129 39129 # take no chances and rewrite it.
39130 39130 # Note: m4 eats our [], so we need to use [ and ] instead.
39131 39131 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
39132 39132 if test "x$has_forbidden_chars" != x; then
39133 39133 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39134 39134 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39135 39135 fi
39136 39136
39137 39137 # Output is in $new_path
39138 39138
39139 39139 windows_path="$new_path"
39140 39140 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39141 39141 unix_path=`$CYGPATH -u "$windows_path"`
39142 39142 new_path="$unix_path"
39143 39143 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39144 39144 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39145 39145 new_path="$unix_path"
39146 39146 fi
39147 39147
39148 39148 # remove trailing .exe if any
39149 39149 new_path="${new_path/%.exe/}"
39150 39150
39151 39151 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39152 39152 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39153 39153 fi
39154 39154
39155 39155 else
39156 39156 # We're on a unix platform. Hooray! :)
39157 39157 # First separate the path from the arguments. This will split at the first
39158 39158 # space.
39159 39159 complete="$RC"
39160 39160 path="${complete%% *}"
39161 39161 tmp="$complete EOL"
39162 39162 arguments="${tmp#* }"
39163 39163
39164 39164 # Cannot rely on the command "which" here since it doesn't always work.
39165 39165 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39166 39166 if test -z "$is_absolute_path"; then
39167 39167 # Path to executable is not absolute. Find it.
39168 39168 IFS_save="$IFS"
39169 39169 IFS=:
39170 39170 for p in $PATH; do
39171 39171 if test -f "$p/$path" && test -x "$p/$path"; then
39172 39172 new_path="$p/$path"
39173 39173 break
39174 39174 fi
39175 39175 done
39176 39176 IFS="$IFS_save"
39177 39177 else
39178 39178 # This is an absolute path, we can use it without further modifications.
39179 39179 new_path="$path"
39180 39180 fi
39181 39181
39182 39182 if test "x$new_path" = x; then
39183 39183 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
39184 39184 $as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
39185 39185 has_space=`$ECHO "$complete" | $GREP " "`
39186 39186 if test "x$has_space" != x; then
39187 39187 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
39188 39188 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
39189 39189 fi
39190 39190 as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
39191 39191 fi
39192 39192 fi
39193 39193
39194 39194 # Now join together the path and the arguments once again
39195 39195 if test "x$arguments" != xEOL; then
39196 39196 new_complete="$new_path ${arguments% *}"
39197 39197 else
39198 39198 new_complete="$new_path"
39199 39199 fi
39200 39200
39201 39201 if test "x$complete" != "x$new_complete"; then
39202 39202 RC="$new_complete"
39203 39203 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
39204 39204 $as_echo "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
39205 39205 fi
39206 39206 fi
39207 39207
39208 39208 # Extract the first word of "dumpbin", so it can be a program name with args.
39209 39209 set dummy dumpbin; ac_word=$2
39210 39210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
39211 39211 $as_echo_n "checking for $ac_word... " >&6; }
39212 39212 if ${ac_cv_prog_DUMPBIN+:} false; then :
39213 39213 $as_echo_n "(cached) " >&6
39214 39214 else
39215 39215 if test -n "$DUMPBIN"; then
39216 39216 ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
39217 39217 else
39218 39218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
39219 39219 for as_dir in $PATH
39220 39220 do
39221 39221 IFS=$as_save_IFS
39222 39222 test -z "$as_dir" && as_dir=.
39223 39223 for ac_exec_ext in '' $ac_executable_extensions; do
39224 39224 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
39225 39225 ac_cv_prog_DUMPBIN="dumpbin"
39226 39226 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
39227 39227 break 2
39228 39228 fi
39229 39229 done
39230 39230 done
39231 39231 IFS=$as_save_IFS
39232 39232
39233 39233 fi
39234 39234 fi
39235 39235 DUMPBIN=$ac_cv_prog_DUMPBIN
39236 39236 if test -n "$DUMPBIN"; then
39237 39237 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
39238 39238 $as_echo "$DUMPBIN" >&6; }
39239 39239 else
39240 39240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
39241 39241 $as_echo "no" >&6; }
39242 39242 fi
39243 39243
39244 39244
39245 39245
39246 39246 # Only process if variable expands to non-empty
39247 39247
39248 39248 if test "x$DUMPBIN" != x; then
39249 39249 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39250 39250
39251 39251 # First separate the path from the arguments. This will split at the first
39252 39252 # space.
39253 39253 complete="$DUMPBIN"
39254 39254 path="${complete%% *}"
39255 39255 tmp="$complete EOL"
39256 39256 arguments="${tmp#* }"
39257 39257
39258 39258 # Input might be given as Windows format, start by converting to
39259 39259 # unix format.
39260 39260 new_path=`$CYGPATH -u "$path"`
39261 39261
39262 39262 # Now try to locate executable using which
39263 39263 new_path=`$WHICH "$new_path" 2> /dev/null`
39264 39264 # bat and cmd files are not always considered executable in cygwin causing which
39265 39265 # to not find them
39266 39266 if test "x$new_path" = x \
39267 39267 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39268 39268 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39269 39269 new_path=`$CYGPATH -u "$path"`
39270 39270 fi
39271 39271 if test "x$new_path" = x; then
39272 39272 # Oops. Which didn't find the executable.
39273 39273 # The splitting of arguments from the executable at a space might have been incorrect,
39274 39274 # since paths with space are more likely in Windows. Give it another try with the whole
39275 39275 # argument.
39276 39276 path="$complete"
39277 39277 arguments="EOL"
39278 39278 new_path=`$CYGPATH -u "$path"`
39279 39279 new_path=`$WHICH "$new_path" 2> /dev/null`
39280 39280 # bat and cmd files are not always considered executable in cygwin causing which
39281 39281 # to not find them
39282 39282 if test "x$new_path" = x \
39283 39283 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39284 39284 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39285 39285 new_path=`$CYGPATH -u "$path"`
39286 39286 fi
39287 39287 if test "x$new_path" = x; then
39288 39288 # It's still not found. Now this is an unrecoverable error.
39289 39289 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
39290 39290 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
39291 39291 has_space=`$ECHO "$complete" | $GREP " "`
39292 39292 if test "x$has_space" != x; then
39293 39293 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39294 39294 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39295 39295 fi
39296 39296 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
39297 39297 fi
39298 39298 fi
39299 39299
39300 39300 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
39301 39301 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
39302 39302 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
39303 39303 # "foo.exe" is OK but "foo" is an error.
39304 39304 #
39305 39305 # This test is therefore slightly more accurate than "test -f" to check for file presence.
39306 39306 # It is also a way to make sure we got the proper file name for the real test later on.
39307 39307 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
39308 39308 if test "x$test_shortpath" = x; then
39309 39309 # Short path failed, file does not exist as specified.
39310 39310 # Try adding .exe or .cmd
39311 39311 if test -f "${new_path}.exe"; then
39312 39312 input_to_shortpath="${new_path}.exe"
39313 39313 elif test -f "${new_path}.cmd"; then
39314 39314 input_to_shortpath="${new_path}.cmd"
39315 39315 else
39316 39316 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
39317 39317 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
39318 39318 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
39319 39319 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
39320 39320 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
39321 39321 fi
39322 39322 else
39323 39323 input_to_shortpath="$new_path"
39324 39324 fi
39325 39325
39326 39326 # Call helper function which possibly converts this using DOS-style short mode.
39327 39327 # If so, the updated path is stored in $new_path.
39328 39328 new_path="$input_to_shortpath"
39329 39329
39330 39330 input_path="$input_to_shortpath"
39331 39331 # Check if we need to convert this using DOS-style short mode. If the path
39332 39332 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39333 39333 # take no chances and rewrite it.
39334 39334 # Note: m4 eats our [], so we need to use [ and ] instead.
39335 39335 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39336 39336 if test "x$has_forbidden_chars" != x; then
39337 39337 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39338 39338 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39339 39339 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39340 39340 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39341 39341 # Going to short mode and back again did indeed matter. Since short mode is
39342 39342 # case insensitive, let's make it lowercase to improve readability.
39343 39343 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39344 39344 # Now convert it back to Unix-style (cygpath)
39345 39345 input_path=`$CYGPATH -u "$shortmode_path"`
39346 39346 new_path="$input_path"
39347 39347 fi
39348 39348 fi
39349 39349
39350 39350 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39351 39351 if test "x$test_cygdrive_prefix" = x; then
39352 39352 # As a simple fix, exclude /usr/bin since it's not a real path.
39353 39353 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39354 39354 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39355 39355 # a path prefixed by /cygdrive for fixpath to work.
39356 39356 new_path="$CYGWIN_ROOT_PATH$input_path"
39357 39357 fi
39358 39358 fi
39359 39359
39360 39360 # remove trailing .exe if any
39361 39361 new_path="${new_path/%.exe/}"
39362 39362
39363 39363 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39364 39364
39365 39365 # First separate the path from the arguments. This will split at the first
39366 39366 # space.
39367 39367 complete="$DUMPBIN"
39368 39368 path="${complete%% *}"
39369 39369 tmp="$complete EOL"
39370 39370 arguments="${tmp#* }"
39371 39371
39372 39372 # Input might be given as Windows format, start by converting to
39373 39373 # unix format.
39374 39374 new_path="$path"
39375 39375
39376 39376 windows_path="$new_path"
39377 39377 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39378 39378 unix_path=`$CYGPATH -u "$windows_path"`
39379 39379 new_path="$unix_path"
39380 39380 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39381 39381 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39382 39382 new_path="$unix_path"
39383 39383 fi
39384 39384
39385 39385
39386 39386 # Now try to locate executable using which
39387 39387 new_path=`$WHICH "$new_path" 2> /dev/null`
39388 39388
39389 39389 if test "x$new_path" = x; then
39390 39390 # Oops. Which didn't find the executable.
39391 39391 # The splitting of arguments from the executable at a space might have been incorrect,
39392 39392 # since paths with space are more likely in Windows. Give it another try with the whole
39393 39393 # argument.
39394 39394 path="$complete"
39395 39395 arguments="EOL"
39396 39396 new_path="$path"
39397 39397
39398 39398 windows_path="$new_path"
39399 39399 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39400 39400 unix_path=`$CYGPATH -u "$windows_path"`
39401 39401 new_path="$unix_path"
39402 39402 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39403 39403 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39404 39404 new_path="$unix_path"
39405 39405 fi
39406 39406
39407 39407
39408 39408 new_path=`$WHICH "$new_path" 2> /dev/null`
39409 39409 # bat and cmd files are not always considered executable in MSYS causing which
39410 39410 # to not find them
39411 39411 if test "x$new_path" = x \
39412 39412 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39413 39413 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39414 39414 new_path="$path"
39415 39415
39416 39416 windows_path="$new_path"
39417 39417 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39418 39418 unix_path=`$CYGPATH -u "$windows_path"`
39419 39419 new_path="$unix_path"
39420 39420 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39421 39421 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39422 39422 new_path="$unix_path"
39423 39423 fi
39424 39424
39425 39425 fi
39426 39426
39427 39427 if test "x$new_path" = x; then
39428 39428 # It's still not found. Now this is an unrecoverable error.
39429 39429 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
39430 39430 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
39431 39431 has_space=`$ECHO "$complete" | $GREP " "`
39432 39432 if test "x$has_space" != x; then
39433 39433 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39434 39434 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39435 39435 fi
39436 39436 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
39437 39437 fi
39438 39438 fi
39439 39439
39440 39440 # Now new_path has a complete unix path to the binary
39441 39441 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39442 39442 # Keep paths in /bin as-is, but remove trailing .exe if any
39443 39443 new_path="${new_path/%.exe/}"
39444 39444 # Do not save /bin paths to all_fixpath_prefixes!
39445 39445 else
39446 39446 # Not in mixed or Windows style, start by that.
39447 39447 new_path=`cmd //c echo $new_path`
39448 39448
39449 39449 input_path="$new_path"
39450 39450 # Check if we need to convert this using DOS-style short mode. If the path
39451 39451 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39452 39452 # take no chances and rewrite it.
39453 39453 # Note: m4 eats our [], so we need to use [ and ] instead.
39454 39454 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
39455 39455 if test "x$has_forbidden_chars" != x; then
39456 39456 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39457 39457 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39458 39458 fi
39459 39459
39460 39460 # Output is in $new_path
39461 39461
39462 39462 windows_path="$new_path"
39463 39463 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39464 39464 unix_path=`$CYGPATH -u "$windows_path"`
39465 39465 new_path="$unix_path"
39466 39466 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39467 39467 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39468 39468 new_path="$unix_path"
39469 39469 fi
39470 39470
39471 39471 # remove trailing .exe if any
39472 39472 new_path="${new_path/%.exe/}"
39473 39473
39474 39474 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39475 39475 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39476 39476 fi
39477 39477
39478 39478 else
39479 39479 # We're on a unix platform. Hooray! :)
39480 39480 # First separate the path from the arguments. This will split at the first
39481 39481 # space.
39482 39482 complete="$DUMPBIN"
39483 39483 path="${complete%% *}"
39484 39484 tmp="$complete EOL"
39485 39485 arguments="${tmp#* }"
39486 39486
39487 39487 # Cannot rely on the command "which" here since it doesn't always work.
39488 39488 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39489 39489 if test -z "$is_absolute_path"; then
39490 39490 # Path to executable is not absolute. Find it.
39491 39491 IFS_save="$IFS"
39492 39492 IFS=:
39493 39493 for p in $PATH; do
39494 39494 if test -f "$p/$path" && test -x "$p/$path"; then
39495 39495 new_path="$p/$path"
39496 39496 break
39497 39497 fi
39498 39498 done
39499 39499 IFS="$IFS_save"
39500 39500 else
39501 39501 # This is an absolute path, we can use it without further modifications.
39502 39502 new_path="$path"
39503 39503 fi
39504 39504
39505 39505 if test "x$new_path" = x; then
39506 39506 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
39507 39507 $as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
39508 39508 has_space=`$ECHO "$complete" | $GREP " "`
39509 39509 if test "x$has_space" != x; then
39510 39510 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
39511 39511 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
39512 39512 fi
39513 39513 as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
39514 39514 fi
39515 39515 fi
39516 39516
39517 39517 # Now join together the path and the arguments once again
39518 39518 if test "x$arguments" != xEOL; then
39519 39519 new_complete="$new_path ${arguments% *}"
39520 39520 else
39521 39521 new_complete="$new_path"
39522 39522 fi
39523 39523
39524 39524 if test "x$complete" != "x$new_complete"; then
39525 39525 DUMPBIN="$new_complete"
39526 39526 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
39527 39527 $as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
39528 39528 fi
39529 39529 fi
39530 39530
39531 39531 # We need to check for 'msbuild.exe' because at the place where we expect to
39532 39532 # find 'msbuild.exe' there's also a directory called 'msbuild' and configure
39533 39533 # won't find the 'msbuild.exe' executable in that case (and the
39534 39534 # 'ac_executable_extensions' is unusable due to performance reasons).
39535 39535 # Notice that we intentionally don't fix up the path to MSBUILD because we
39536 39536 # will call it in a DOS shell during freetype detection on Windows (see
39537 39537 # 'LIB_SETUP_FREETYPE' in "libraries.m4"
39538 39538 # Extract the first word of "msbuild.exe", so it can be a program name with args.
39539 39539 set dummy msbuild.exe; ac_word=$2
39540 39540 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
39541 39541 $as_echo_n "checking for $ac_word... " >&6; }
39542 39542 if ${ac_cv_prog_MSBUILD+:} false; then :
39543 39543 $as_echo_n "(cached) " >&6
39544 39544 else
39545 39545 if test -n "$MSBUILD"; then
39546 39546 ac_cv_prog_MSBUILD="$MSBUILD" # Let the user override the test.
39547 39547 else
39548 39548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
39549 39549 for as_dir in $PATH
39550 39550 do
39551 39551 IFS=$as_save_IFS
39552 39552 test -z "$as_dir" && as_dir=.
39553 39553 for ac_exec_ext in '' $ac_executable_extensions; do
39554 39554 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
39555 39555 ac_cv_prog_MSBUILD="msbuild.exe"
39556 39556 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
39557 39557 break 2
39558 39558 fi
39559 39559 done
39560 39560 done
39561 39561 IFS=$as_save_IFS
39562 39562
39563 39563 fi
39564 39564 fi
39565 39565 MSBUILD=$ac_cv_prog_MSBUILD
39566 39566 if test -n "$MSBUILD"; then
39567 39567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
39568 39568 $as_echo "$MSBUILD" >&6; }
39569 39569 else
39570 39570 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
39571 39571 $as_echo "no" >&6; }
39572 39572 fi
39573 39573
39574 39574
39575 39575 fi
39576 39576
39577 39577 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
39578 39578
39579 39579
39580 39580 # Publish this variable in the help.
39581 39581
39582 39582
39583 39583 if [ -z "${STRIP+x}" ]; then
39584 39584 # The variable is not set by user, try to locate tool using the code snippet
39585 39585 for ac_prog in strip
39586 39586 do
39587 39587 # Extract the first word of "$ac_prog", so it can be a program name with args.
39588 39588 set dummy $ac_prog; ac_word=$2
39589 39589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
39590 39590 $as_echo_n "checking for $ac_word... " >&6; }
39591 39591 if ${ac_cv_path_STRIP+:} false; then :
39592 39592 $as_echo_n "(cached) " >&6
39593 39593 else
39594 39594 case $STRIP in
39595 39595 [\\/]* | ?:[\\/]*)
39596 39596 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
39597 39597 ;;
39598 39598 *)
39599 39599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
39600 39600 for as_dir in $PATH
39601 39601 do
39602 39602 IFS=$as_save_IFS
39603 39603 test -z "$as_dir" && as_dir=.
39604 39604 for ac_exec_ext in '' $ac_executable_extensions; do
39605 39605 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
39606 39606 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
39607 39607 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
39608 39608 break 2
39609 39609 fi
39610 39610 done
39611 39611 done
39612 39612 IFS=$as_save_IFS
39613 39613
39614 39614 ;;
39615 39615 esac
39616 39616 fi
39617 39617 STRIP=$ac_cv_path_STRIP
39618 39618 if test -n "$STRIP"; then
39619 39619 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
39620 39620 $as_echo "$STRIP" >&6; }
39621 39621 else
39622 39622 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
39623 39623 $as_echo "no" >&6; }
39624 39624 fi
39625 39625
39626 39626
39627 39627 test -n "$STRIP" && break
39628 39628 done
39629 39629
39630 39630 else
39631 39631 # The variable is set, but is it from the command line or the environment?
39632 39632
39633 39633 # Try to remove the string !STRIP! from our list.
39634 39634 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
39635 39635 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
39636 39636 # If it failed, the variable was not from the command line. Ignore it,
39637 39637 # but warn the user (except for BASH, which is always set by the calling BASH).
39638 39638 if test "xSTRIP" != xBASH; then
39639 39639 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
39640 39640 $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
39641 39641 fi
39642 39642 # Try to locate tool using the code snippet
39643 39643 for ac_prog in strip
39644 39644 do
39645 39645 # Extract the first word of "$ac_prog", so it can be a program name with args.
39646 39646 set dummy $ac_prog; ac_word=$2
39647 39647 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
39648 39648 $as_echo_n "checking for $ac_word... " >&6; }
39649 39649 if ${ac_cv_path_STRIP+:} false; then :
39650 39650 $as_echo_n "(cached) " >&6
39651 39651 else
39652 39652 case $STRIP in
39653 39653 [\\/]* | ?:[\\/]*)
39654 39654 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
39655 39655 ;;
39656 39656 *)
39657 39657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
39658 39658 for as_dir in $PATH
39659 39659 do
39660 39660 IFS=$as_save_IFS
39661 39661 test -z "$as_dir" && as_dir=.
39662 39662 for ac_exec_ext in '' $ac_executable_extensions; do
39663 39663 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
39664 39664 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
39665 39665 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
39666 39666 break 2
39667 39667 fi
39668 39668 done
39669 39669 done
39670 39670 IFS=$as_save_IFS
39671 39671
39672 39672 ;;
39673 39673 esac
39674 39674 fi
39675 39675 STRIP=$ac_cv_path_STRIP
39676 39676 if test -n "$STRIP"; then
39677 39677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
39678 39678 $as_echo "$STRIP" >&6; }
39679 39679 else
39680 39680 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
39681 39681 $as_echo "no" >&6; }
39682 39682 fi
39683 39683
39684 39684
39685 39685 test -n "$STRIP" && break
39686 39686 done
39687 39687
39688 39688 else
39689 39689 # If it succeeded, then it was overridden by the user. We will use it
39690 39690 # for the tool.
39691 39691
39692 39692 # First remove it from the list of overridden variables, so we can test
39693 39693 # for unknown variables in the end.
39694 39694 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
39695 39695
39696 39696 # Check if we try to supply an empty value
39697 39697 if test "x$STRIP" = x; then
39698 39698 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STRIP= (no value)" >&5
39699 39699 $as_echo "$as_me: Setting user supplied tool STRIP= (no value)" >&6;}
39700 39700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
39701 39701 $as_echo_n "checking for STRIP... " >&6; }
39702 39702 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
39703 39703 $as_echo "disabled" >&6; }
39704 39704 else
39705 39705 # Check if the provided tool contains a complete path.
39706 39706 tool_specified="$STRIP"
39707 39707 tool_basename="${tool_specified##*/}"
39708 39708 if test "x$tool_basename" = "x$tool_specified"; then
39709 39709 # A command without a complete path is provided, search $PATH.
39710 39710 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
39711 39711 $as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
39712 39712 # Extract the first word of "$tool_basename", so it can be a program name with args.
39713 39713 set dummy $tool_basename; ac_word=$2
39714 39714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
39715 39715 $as_echo_n "checking for $ac_word... " >&6; }
39716 39716 if ${ac_cv_path_STRIP+:} false; then :
39717 39717 $as_echo_n "(cached) " >&6
39718 39718 else
39719 39719 case $STRIP in
39720 39720 [\\/]* | ?:[\\/]*)
39721 39721 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
39722 39722 ;;
39723 39723 *)
39724 39724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
39725 39725 for as_dir in $PATH
39726 39726 do
39727 39727 IFS=$as_save_IFS
39728 39728 test -z "$as_dir" && as_dir=.
39729 39729 for ac_exec_ext in '' $ac_executable_extensions; do
39730 39730 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
39731 39731 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
39732 39732 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
39733 39733 break 2
39734 39734 fi
39735 39735 done
39736 39736 done
39737 39737 IFS=$as_save_IFS
39738 39738
39739 39739 ;;
39740 39740 esac
39741 39741 fi
39742 39742 STRIP=$ac_cv_path_STRIP
39743 39743 if test -n "$STRIP"; then
39744 39744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
39745 39745 $as_echo "$STRIP" >&6; }
39746 39746 else
39747 39747 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
39748 39748 $as_echo "no" >&6; }
39749 39749 fi
39750 39750
39751 39751
39752 39752 if test "x$STRIP" = x; then
39753 39753 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
39754 39754 fi
39755 39755 else
39756 39756 # Otherwise we believe it is a complete path. Use it as it is.
39757 39757 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
39758 39758 $as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
39759 39759 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
39760 39760 $as_echo_n "checking for STRIP... " >&6; }
39761 39761 if test ! -x "$tool_specified"; then
39762 39762 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
39763 39763 $as_echo "not found" >&6; }
39764 39764 as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
39765 39765 fi
39766 39766 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
39767 39767 $as_echo "$tool_specified" >&6; }
39768 39768 fi
39769 39769 fi
39770 39770 fi
39771 39771
39772 39772 fi
39773 39773
39774 39774
39775 39775
39776 39776 # Only process if variable expands to non-empty
39777 39777
39778 39778 if test "x$STRIP" != x; then
39779 39779 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39780 39780
39781 39781 # First separate the path from the arguments. This will split at the first
39782 39782 # space.
39783 39783 complete="$STRIP"
39784 39784 path="${complete%% *}"
39785 39785 tmp="$complete EOL"
39786 39786 arguments="${tmp#* }"
39787 39787
39788 39788 # Input might be given as Windows format, start by converting to
39789 39789 # unix format.
39790 39790 new_path=`$CYGPATH -u "$path"`
39791 39791
39792 39792 # Now try to locate executable using which
39793 39793 new_path=`$WHICH "$new_path" 2> /dev/null`
39794 39794 # bat and cmd files are not always considered executable in cygwin causing which
39795 39795 # to not find them
39796 39796 if test "x$new_path" = x \
39797 39797 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39798 39798 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39799 39799 new_path=`$CYGPATH -u "$path"`
39800 39800 fi
39801 39801 if test "x$new_path" = x; then
39802 39802 # Oops. Which didn't find the executable.
39803 39803 # The splitting of arguments from the executable at a space might have been incorrect,
39804 39804 # since paths with space are more likely in Windows. Give it another try with the whole
39805 39805 # argument.
39806 39806 path="$complete"
39807 39807 arguments="EOL"
39808 39808 new_path=`$CYGPATH -u "$path"`
39809 39809 new_path=`$WHICH "$new_path" 2> /dev/null`
39810 39810 # bat and cmd files are not always considered executable in cygwin causing which
39811 39811 # to not find them
39812 39812 if test "x$new_path" = x \
39813 39813 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39814 39814 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39815 39815 new_path=`$CYGPATH -u "$path"`
39816 39816 fi
39817 39817 if test "x$new_path" = x; then
39818 39818 # It's still not found. Now this is an unrecoverable error.
39819 39819 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
39820 39820 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
39821 39821 has_space=`$ECHO "$complete" | $GREP " "`
39822 39822 if test "x$has_space" != x; then
39823 39823 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39824 39824 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39825 39825 fi
39826 39826 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
39827 39827 fi
39828 39828 fi
39829 39829
39830 39830 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
39831 39831 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
39832 39832 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
39833 39833 # "foo.exe" is OK but "foo" is an error.
39834 39834 #
39835 39835 # This test is therefore slightly more accurate than "test -f" to check for file presence.
39836 39836 # It is also a way to make sure we got the proper file name for the real test later on.
39837 39837 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
39838 39838 if test "x$test_shortpath" = x; then
39839 39839 # Short path failed, file does not exist as specified.
39840 39840 # Try adding .exe or .cmd
39841 39841 if test -f "${new_path}.exe"; then
39842 39842 input_to_shortpath="${new_path}.exe"
39843 39843 elif test -f "${new_path}.cmd"; then
39844 39844 input_to_shortpath="${new_path}.cmd"
39845 39845 else
39846 39846 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
39847 39847 $as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
39848 39848 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
39849 39849 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
39850 39850 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
39851 39851 fi
39852 39852 else
39853 39853 input_to_shortpath="$new_path"
39854 39854 fi
39855 39855
39856 39856 # Call helper function which possibly converts this using DOS-style short mode.
39857 39857 # If so, the updated path is stored in $new_path.
39858 39858 new_path="$input_to_shortpath"
39859 39859
39860 39860 input_path="$input_to_shortpath"
39861 39861 # Check if we need to convert this using DOS-style short mode. If the path
39862 39862 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39863 39863 # take no chances and rewrite it.
39864 39864 # Note: m4 eats our [], so we need to use [ and ] instead.
39865 39865 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39866 39866 if test "x$has_forbidden_chars" != x; then
39867 39867 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39868 39868 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39869 39869 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39870 39870 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39871 39871 # Going to short mode and back again did indeed matter. Since short mode is
39872 39872 # case insensitive, let's make it lowercase to improve readability.
39873 39873 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39874 39874 # Now convert it back to Unix-style (cygpath)
39875 39875 input_path=`$CYGPATH -u "$shortmode_path"`
39876 39876 new_path="$input_path"
39877 39877 fi
39878 39878 fi
39879 39879
39880 39880 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39881 39881 if test "x$test_cygdrive_prefix" = x; then
39882 39882 # As a simple fix, exclude /usr/bin since it's not a real path.
39883 39883 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39884 39884 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39885 39885 # a path prefixed by /cygdrive for fixpath to work.
39886 39886 new_path="$CYGWIN_ROOT_PATH$input_path"
39887 39887 fi
39888 39888 fi
39889 39889
39890 39890 # remove trailing .exe if any
39891 39891 new_path="${new_path/%.exe/}"
39892 39892
39893 39893 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39894 39894
39895 39895 # First separate the path from the arguments. This will split at the first
39896 39896 # space.
39897 39897 complete="$STRIP"
39898 39898 path="${complete%% *}"
39899 39899 tmp="$complete EOL"
39900 39900 arguments="${tmp#* }"
39901 39901
39902 39902 # Input might be given as Windows format, start by converting to
39903 39903 # unix format.
39904 39904 new_path="$path"
39905 39905
39906 39906 windows_path="$new_path"
39907 39907 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39908 39908 unix_path=`$CYGPATH -u "$windows_path"`
39909 39909 new_path="$unix_path"
39910 39910 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39911 39911 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39912 39912 new_path="$unix_path"
39913 39913 fi
39914 39914
39915 39915
39916 39916 # Now try to locate executable using which
39917 39917 new_path=`$WHICH "$new_path" 2> /dev/null`
39918 39918
39919 39919 if test "x$new_path" = x; then
39920 39920 # Oops. Which didn't find the executable.
39921 39921 # The splitting of arguments from the executable at a space might have been incorrect,
39922 39922 # since paths with space are more likely in Windows. Give it another try with the whole
39923 39923 # argument.
39924 39924 path="$complete"
39925 39925 arguments="EOL"
39926 39926 new_path="$path"
39927 39927
39928 39928 windows_path="$new_path"
39929 39929 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39930 39930 unix_path=`$CYGPATH -u "$windows_path"`
39931 39931 new_path="$unix_path"
39932 39932 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39933 39933 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39934 39934 new_path="$unix_path"
39935 39935 fi
39936 39936
39937 39937
39938 39938 new_path=`$WHICH "$new_path" 2> /dev/null`
39939 39939 # bat and cmd files are not always considered executable in MSYS causing which
39940 39940 # to not find them
39941 39941 if test "x$new_path" = x \
39942 39942 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
39943 39943 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
39944 39944 new_path="$path"
39945 39945
39946 39946 windows_path="$new_path"
39947 39947 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39948 39948 unix_path=`$CYGPATH -u "$windows_path"`
39949 39949 new_path="$unix_path"
39950 39950 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39951 39951 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39952 39952 new_path="$unix_path"
39953 39953 fi
39954 39954
39955 39955 fi
39956 39956
39957 39957 if test "x$new_path" = x; then
39958 39958 # It's still not found. Now this is an unrecoverable error.
39959 39959 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
39960 39960 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
39961 39961 has_space=`$ECHO "$complete" | $GREP " "`
39962 39962 if test "x$has_space" != x; then
39963 39963 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
39964 39964 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
39965 39965 fi
39966 39966 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
39967 39967 fi
39968 39968 fi
39969 39969
39970 39970 # Now new_path has a complete unix path to the binary
39971 39971 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
39972 39972 # Keep paths in /bin as-is, but remove trailing .exe if any
39973 39973 new_path="${new_path/%.exe/}"
39974 39974 # Do not save /bin paths to all_fixpath_prefixes!
39975 39975 else
39976 39976 # Not in mixed or Windows style, start by that.
39977 39977 new_path=`cmd //c echo $new_path`
39978 39978
39979 39979 input_path="$new_path"
39980 39980 # Check if we need to convert this using DOS-style short mode. If the path
39981 39981 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39982 39982 # take no chances and rewrite it.
39983 39983 # Note: m4 eats our [], so we need to use [ and ] instead.
39984 39984 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
39985 39985 if test "x$has_forbidden_chars" != x; then
39986 39986 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39987 39987 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39988 39988 fi
39989 39989
39990 39990 # Output is in $new_path
39991 39991
39992 39992 windows_path="$new_path"
39993 39993 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39994 39994 unix_path=`$CYGPATH -u "$windows_path"`
39995 39995 new_path="$unix_path"
39996 39996 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39997 39997 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39998 39998 new_path="$unix_path"
39999 39999 fi
40000 40000
40001 40001 # remove trailing .exe if any
40002 40002 new_path="${new_path/%.exe/}"
40003 40003
40004 40004 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40005 40005 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40006 40006 fi
40007 40007
40008 40008 else
40009 40009 # We're on a unix platform. Hooray! :)
40010 40010 # First separate the path from the arguments. This will split at the first
40011 40011 # space.
40012 40012 complete="$STRIP"
40013 40013 path="${complete%% *}"
40014 40014 tmp="$complete EOL"
40015 40015 arguments="${tmp#* }"
40016 40016
40017 40017 # Cannot rely on the command "which" here since it doesn't always work.
40018 40018 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40019 40019 if test -z "$is_absolute_path"; then
40020 40020 # Path to executable is not absolute. Find it.
40021 40021 IFS_save="$IFS"
40022 40022 IFS=:
40023 40023 for p in $PATH; do
40024 40024 if test -f "$p/$path" && test -x "$p/$path"; then
40025 40025 new_path="$p/$path"
40026 40026 break
40027 40027 fi
40028 40028 done
40029 40029 IFS="$IFS_save"
40030 40030 else
40031 40031 # This is an absolute path, we can use it without further modifications.
40032 40032 new_path="$path"
40033 40033 fi
40034 40034
40035 40035 if test "x$new_path" = x; then
40036 40036 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
40037 40037 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
40038 40038 has_space=`$ECHO "$complete" | $GREP " "`
40039 40039 if test "x$has_space" != x; then
40040 40040 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
40041 40041 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
40042 40042 fi
40043 40043 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
40044 40044 fi
40045 40045 fi
40046 40046
40047 40047 # Now join together the path and the arguments once again
40048 40048 if test "x$arguments" != xEOL; then
40049 40049 new_complete="$new_path ${arguments% *}"
40050 40050 else
40051 40051 new_complete="$new_path"
40052 40052 fi
40053 40053
40054 40054 if test "x$complete" != "x$new_complete"; then
40055 40055 STRIP="$new_complete"
40056 40056 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
40057 40057 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
40058 40058 fi
40059 40059 fi
40060 40060
40061 40061
40062 40062
40063 40063 # Publish this variable in the help.
40064 40064
40065 40065
40066 40066 if [ -z "${NM+x}" ]; then
40067 40067 # The variable is not set by user, try to locate tool using the code snippet
40068 40068 for ac_prog in nm
40069 40069 do
40070 40070 # Extract the first word of "$ac_prog", so it can be a program name with args.
40071 40071 set dummy $ac_prog; ac_word=$2
40072 40072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40073 40073 $as_echo_n "checking for $ac_word... " >&6; }
40074 40074 if ${ac_cv_path_NM+:} false; then :
40075 40075 $as_echo_n "(cached) " >&6
40076 40076 else
40077 40077 case $NM in
40078 40078 [\\/]* | ?:[\\/]*)
40079 40079 ac_cv_path_NM="$NM" # Let the user override the test with a path.
40080 40080 ;;
40081 40081 *)
40082 40082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40083 40083 for as_dir in $PATH
40084 40084 do
40085 40085 IFS=$as_save_IFS
40086 40086 test -z "$as_dir" && as_dir=.
40087 40087 for ac_exec_ext in '' $ac_executable_extensions; do
40088 40088 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40089 40089 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
40090 40090 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40091 40091 break 2
40092 40092 fi
40093 40093 done
40094 40094 done
40095 40095 IFS=$as_save_IFS
40096 40096
40097 40097 ;;
40098 40098 esac
40099 40099 fi
40100 40100 NM=$ac_cv_path_NM
40101 40101 if test -n "$NM"; then
40102 40102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
40103 40103 $as_echo "$NM" >&6; }
40104 40104 else
40105 40105 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40106 40106 $as_echo "no" >&6; }
40107 40107 fi
40108 40108
40109 40109
40110 40110 test -n "$NM" && break
40111 40111 done
40112 40112
40113 40113 else
40114 40114 # The variable is set, but is it from the command line or the environment?
40115 40115
40116 40116 # Try to remove the string !NM! from our list.
40117 40117 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
40118 40118 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
40119 40119 # If it failed, the variable was not from the command line. Ignore it,
40120 40120 # but warn the user (except for BASH, which is always set by the calling BASH).
40121 40121 if test "xNM" != xBASH; then
40122 40122 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
40123 40123 $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
40124 40124 fi
40125 40125 # Try to locate tool using the code snippet
40126 40126 for ac_prog in nm
40127 40127 do
40128 40128 # Extract the first word of "$ac_prog", so it can be a program name with args.
40129 40129 set dummy $ac_prog; ac_word=$2
40130 40130 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40131 40131 $as_echo_n "checking for $ac_word... " >&6; }
40132 40132 if ${ac_cv_path_NM+:} false; then :
40133 40133 $as_echo_n "(cached) " >&6
40134 40134 else
40135 40135 case $NM in
40136 40136 [\\/]* | ?:[\\/]*)
40137 40137 ac_cv_path_NM="$NM" # Let the user override the test with a path.
40138 40138 ;;
40139 40139 *)
40140 40140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40141 40141 for as_dir in $PATH
40142 40142 do
40143 40143 IFS=$as_save_IFS
40144 40144 test -z "$as_dir" && as_dir=.
40145 40145 for ac_exec_ext in '' $ac_executable_extensions; do
40146 40146 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40147 40147 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
40148 40148 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40149 40149 break 2
40150 40150 fi
40151 40151 done
40152 40152 done
40153 40153 IFS=$as_save_IFS
40154 40154
40155 40155 ;;
40156 40156 esac
40157 40157 fi
40158 40158 NM=$ac_cv_path_NM
40159 40159 if test -n "$NM"; then
40160 40160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
40161 40161 $as_echo "$NM" >&6; }
40162 40162 else
40163 40163 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40164 40164 $as_echo "no" >&6; }
40165 40165 fi
40166 40166
40167 40167
40168 40168 test -n "$NM" && break
40169 40169 done
40170 40170
40171 40171 else
40172 40172 # If it succeeded, then it was overridden by the user. We will use it
40173 40173 # for the tool.
40174 40174
40175 40175 # First remove it from the list of overridden variables, so we can test
40176 40176 # for unknown variables in the end.
40177 40177 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
40178 40178
40179 40179 # Check if we try to supply an empty value
40180 40180 if test "x$NM" = x; then
40181 40181 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
40182 40182 $as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
40183 40183 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
40184 40184 $as_echo_n "checking for NM... " >&6; }
40185 40185 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
40186 40186 $as_echo "disabled" >&6; }
40187 40187 else
40188 40188 # Check if the provided tool contains a complete path.
40189 40189 tool_specified="$NM"
40190 40190 tool_basename="${tool_specified##*/}"
40191 40191 if test "x$tool_basename" = "x$tool_specified"; then
40192 40192 # A command without a complete path is provided, search $PATH.
40193 40193 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
40194 40194 $as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
40195 40195 # Extract the first word of "$tool_basename", so it can be a program name with args.
40196 40196 set dummy $tool_basename; ac_word=$2
40197 40197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40198 40198 $as_echo_n "checking for $ac_word... " >&6; }
40199 40199 if ${ac_cv_path_NM+:} false; then :
40200 40200 $as_echo_n "(cached) " >&6
40201 40201 else
40202 40202 case $NM in
40203 40203 [\\/]* | ?:[\\/]*)
40204 40204 ac_cv_path_NM="$NM" # Let the user override the test with a path.
40205 40205 ;;
40206 40206 *)
40207 40207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40208 40208 for as_dir in $PATH
40209 40209 do
40210 40210 IFS=$as_save_IFS
40211 40211 test -z "$as_dir" && as_dir=.
40212 40212 for ac_exec_ext in '' $ac_executable_extensions; do
40213 40213 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40214 40214 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
40215 40215 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40216 40216 break 2
40217 40217 fi
40218 40218 done
40219 40219 done
40220 40220 IFS=$as_save_IFS
40221 40221
40222 40222 ;;
40223 40223 esac
40224 40224 fi
40225 40225 NM=$ac_cv_path_NM
40226 40226 if test -n "$NM"; then
40227 40227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
40228 40228 $as_echo "$NM" >&6; }
40229 40229 else
40230 40230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40231 40231 $as_echo "no" >&6; }
40232 40232 fi
40233 40233
40234 40234
40235 40235 if test "x$NM" = x; then
40236 40236 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
40237 40237 fi
40238 40238 else
40239 40239 # Otherwise we believe it is a complete path. Use it as it is.
40240 40240 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
40241 40241 $as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
40242 40242 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
40243 40243 $as_echo_n "checking for NM... " >&6; }
40244 40244 if test ! -x "$tool_specified"; then
40245 40245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
40246 40246 $as_echo "not found" >&6; }
40247 40247 as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
40248 40248 fi
40249 40249 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
40250 40250 $as_echo "$tool_specified" >&6; }
40251 40251 fi
40252 40252 fi
40253 40253 fi
40254 40254
40255 40255 fi
40256 40256
40257 40257
40258 40258
40259 40259 # Only process if variable expands to non-empty
40260 40260
40261 40261 if test "x$NM" != x; then
40262 40262 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40263 40263
40264 40264 # First separate the path from the arguments. This will split at the first
40265 40265 # space.
40266 40266 complete="$NM"
40267 40267 path="${complete%% *}"
40268 40268 tmp="$complete EOL"
40269 40269 arguments="${tmp#* }"
40270 40270
40271 40271 # Input might be given as Windows format, start by converting to
40272 40272 # unix format.
40273 40273 new_path=`$CYGPATH -u "$path"`
40274 40274
40275 40275 # Now try to locate executable using which
40276 40276 new_path=`$WHICH "$new_path" 2> /dev/null`
40277 40277 # bat and cmd files are not always considered executable in cygwin causing which
40278 40278 # to not find them
40279 40279 if test "x$new_path" = x \
40280 40280 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40281 40281 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40282 40282 new_path=`$CYGPATH -u "$path"`
40283 40283 fi
40284 40284 if test "x$new_path" = x; then
40285 40285 # Oops. Which didn't find the executable.
40286 40286 # The splitting of arguments from the executable at a space might have been incorrect,
40287 40287 # since paths with space are more likely in Windows. Give it another try with the whole
40288 40288 # argument.
40289 40289 path="$complete"
40290 40290 arguments="EOL"
40291 40291 new_path=`$CYGPATH -u "$path"`
40292 40292 new_path=`$WHICH "$new_path" 2> /dev/null`
40293 40293 # bat and cmd files are not always considered executable in cygwin causing which
40294 40294 # to not find them
40295 40295 if test "x$new_path" = x \
40296 40296 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40297 40297 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40298 40298 new_path=`$CYGPATH -u "$path"`
40299 40299 fi
40300 40300 if test "x$new_path" = x; then
40301 40301 # It's still not found. Now this is an unrecoverable error.
40302 40302 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
40303 40303 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
40304 40304 has_space=`$ECHO "$complete" | $GREP " "`
40305 40305 if test "x$has_space" != x; then
40306 40306 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40307 40307 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40308 40308 fi
40309 40309 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
40310 40310 fi
40311 40311 fi
40312 40312
40313 40313 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
40314 40314 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
40315 40315 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
40316 40316 # "foo.exe" is OK but "foo" is an error.
40317 40317 #
40318 40318 # This test is therefore slightly more accurate than "test -f" to check for file presence.
40319 40319 # It is also a way to make sure we got the proper file name for the real test later on.
40320 40320 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
40321 40321 if test "x$test_shortpath" = x; then
40322 40322 # Short path failed, file does not exist as specified.
40323 40323 # Try adding .exe or .cmd
40324 40324 if test -f "${new_path}.exe"; then
40325 40325 input_to_shortpath="${new_path}.exe"
40326 40326 elif test -f "${new_path}.cmd"; then
40327 40327 input_to_shortpath="${new_path}.cmd"
40328 40328 else
40329 40329 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
40330 40330 $as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
40331 40331 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
40332 40332 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
40333 40333 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
40334 40334 fi
40335 40335 else
40336 40336 input_to_shortpath="$new_path"
40337 40337 fi
40338 40338
40339 40339 # Call helper function which possibly converts this using DOS-style short mode.
40340 40340 # If so, the updated path is stored in $new_path.
40341 40341 new_path="$input_to_shortpath"
40342 40342
40343 40343 input_path="$input_to_shortpath"
40344 40344 # Check if we need to convert this using DOS-style short mode. If the path
40345 40345 # contains just simple characters, use it. Otherwise (spaces, weird characters),
40346 40346 # take no chances and rewrite it.
40347 40347 # Note: m4 eats our [], so we need to use [ and ] instead.
40348 40348 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
40349 40349 if test "x$has_forbidden_chars" != x; then
40350 40350 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
40351 40351 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
40352 40352 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
40353 40353 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
40354 40354 # Going to short mode and back again did indeed matter. Since short mode is
40355 40355 # case insensitive, let's make it lowercase to improve readability.
40356 40356 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
40357 40357 # Now convert it back to Unix-style (cygpath)
40358 40358 input_path=`$CYGPATH -u "$shortmode_path"`
40359 40359 new_path="$input_path"
40360 40360 fi
40361 40361 fi
40362 40362
40363 40363 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
40364 40364 if test "x$test_cygdrive_prefix" = x; then
40365 40365 # As a simple fix, exclude /usr/bin since it's not a real path.
40366 40366 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
40367 40367 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
40368 40368 # a path prefixed by /cygdrive for fixpath to work.
40369 40369 new_path="$CYGWIN_ROOT_PATH$input_path"
40370 40370 fi
40371 40371 fi
40372 40372
40373 40373 # remove trailing .exe if any
40374 40374 new_path="${new_path/%.exe/}"
40375 40375
40376 40376 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40377 40377
40378 40378 # First separate the path from the arguments. This will split at the first
40379 40379 # space.
40380 40380 complete="$NM"
40381 40381 path="${complete%% *}"
40382 40382 tmp="$complete EOL"
40383 40383 arguments="${tmp#* }"
40384 40384
40385 40385 # Input might be given as Windows format, start by converting to
40386 40386 # unix format.
40387 40387 new_path="$path"
40388 40388
40389 40389 windows_path="$new_path"
40390 40390 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40391 40391 unix_path=`$CYGPATH -u "$windows_path"`
40392 40392 new_path="$unix_path"
40393 40393 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40394 40394 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40395 40395 new_path="$unix_path"
40396 40396 fi
40397 40397
40398 40398
40399 40399 # Now try to locate executable using which
40400 40400 new_path=`$WHICH "$new_path" 2> /dev/null`
40401 40401
40402 40402 if test "x$new_path" = x; then
40403 40403 # Oops. Which didn't find the executable.
40404 40404 # The splitting of arguments from the executable at a space might have been incorrect,
40405 40405 # since paths with space are more likely in Windows. Give it another try with the whole
40406 40406 # argument.
40407 40407 path="$complete"
40408 40408 arguments="EOL"
40409 40409 new_path="$path"
40410 40410
40411 40411 windows_path="$new_path"
40412 40412 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40413 40413 unix_path=`$CYGPATH -u "$windows_path"`
40414 40414 new_path="$unix_path"
40415 40415 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40416 40416 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40417 40417 new_path="$unix_path"
40418 40418 fi
40419 40419
40420 40420
40421 40421 new_path=`$WHICH "$new_path" 2> /dev/null`
40422 40422 # bat and cmd files are not always considered executable in MSYS causing which
40423 40423 # to not find them
40424 40424 if test "x$new_path" = x \
40425 40425 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40426 40426 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40427 40427 new_path="$path"
40428 40428
40429 40429 windows_path="$new_path"
40430 40430 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40431 40431 unix_path=`$CYGPATH -u "$windows_path"`
40432 40432 new_path="$unix_path"
40433 40433 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40434 40434 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40435 40435 new_path="$unix_path"
40436 40436 fi
40437 40437
40438 40438 fi
40439 40439
40440 40440 if test "x$new_path" = x; then
40441 40441 # It's still not found. Now this is an unrecoverable error.
40442 40442 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
40443 40443 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
40444 40444 has_space=`$ECHO "$complete" | $GREP " "`
40445 40445 if test "x$has_space" != x; then
40446 40446 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40447 40447 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40448 40448 fi
40449 40449 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
40450 40450 fi
40451 40451 fi
40452 40452
40453 40453 # Now new_path has a complete unix path to the binary
40454 40454 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
40455 40455 # Keep paths in /bin as-is, but remove trailing .exe if any
40456 40456 new_path="${new_path/%.exe/}"
40457 40457 # Do not save /bin paths to all_fixpath_prefixes!
40458 40458 else
40459 40459 # Not in mixed or Windows style, start by that.
40460 40460 new_path=`cmd //c echo $new_path`
40461 40461
40462 40462 input_path="$new_path"
40463 40463 # Check if we need to convert this using DOS-style short mode. If the path
40464 40464 # contains just simple characters, use it. Otherwise (spaces, weird characters),
40465 40465 # take no chances and rewrite it.
40466 40466 # Note: m4 eats our [], so we need to use [ and ] instead.
40467 40467 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
40468 40468 if test "x$has_forbidden_chars" != x; then
40469 40469 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
40470 40470 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
40471 40471 fi
40472 40472
40473 40473 # Output is in $new_path
40474 40474
40475 40475 windows_path="$new_path"
40476 40476 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40477 40477 unix_path=`$CYGPATH -u "$windows_path"`
40478 40478 new_path="$unix_path"
40479 40479 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40480 40480 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40481 40481 new_path="$unix_path"
40482 40482 fi
40483 40483
40484 40484 # remove trailing .exe if any
40485 40485 new_path="${new_path/%.exe/}"
40486 40486
40487 40487 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40488 40488 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40489 40489 fi
40490 40490
40491 40491 else
40492 40492 # We're on a unix platform. Hooray! :)
40493 40493 # First separate the path from the arguments. This will split at the first
40494 40494 # space.
40495 40495 complete="$NM"
40496 40496 path="${complete%% *}"
40497 40497 tmp="$complete EOL"
40498 40498 arguments="${tmp#* }"
40499 40499
40500 40500 # Cannot rely on the command "which" here since it doesn't always work.
40501 40501 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40502 40502 if test -z "$is_absolute_path"; then
40503 40503 # Path to executable is not absolute. Find it.
40504 40504 IFS_save="$IFS"
40505 40505 IFS=:
40506 40506 for p in $PATH; do
40507 40507 if test -f "$p/$path" && test -x "$p/$path"; then
40508 40508 new_path="$p/$path"
40509 40509 break
40510 40510 fi
40511 40511 done
40512 40512 IFS="$IFS_save"
40513 40513 else
40514 40514 # This is an absolute path, we can use it without further modifications.
40515 40515 new_path="$path"
40516 40516 fi
40517 40517
40518 40518 if test "x$new_path" = x; then
40519 40519 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
40520 40520 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
40521 40521 has_space=`$ECHO "$complete" | $GREP " "`
40522 40522 if test "x$has_space" != x; then
40523 40523 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
40524 40524 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
40525 40525 fi
40526 40526 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
40527 40527 fi
40528 40528 fi
40529 40529
40530 40530 # Now join together the path and the arguments once again
40531 40531 if test "x$arguments" != xEOL; then
40532 40532 new_complete="$new_path ${arguments% *}"
40533 40533 else
40534 40534 new_complete="$new_path"
40535 40535 fi
40536 40536
40537 40537 if test "x$complete" != "x$new_complete"; then
40538 40538 NM="$new_complete"
40539 40539 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
40540 40540 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
40541 40541 fi
40542 40542 fi
40543 40543
40544 40544
40545 40545
40546 40546 # Publish this variable in the help.
40547 40547
40548 40548
40549 40549 if [ -z "${GNM+x}" ]; then
40550 40550 # The variable is not set by user, try to locate tool using the code snippet
40551 40551 for ac_prog in gnm
40552 40552 do
40553 40553 # Extract the first word of "$ac_prog", so it can be a program name with args.
40554 40554 set dummy $ac_prog; ac_word=$2
40555 40555 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40556 40556 $as_echo_n "checking for $ac_word... " >&6; }
40557 40557 if ${ac_cv_path_GNM+:} false; then :
40558 40558 $as_echo_n "(cached) " >&6
40559 40559 else
40560 40560 case $GNM in
40561 40561 [\\/]* | ?:[\\/]*)
40562 40562 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
40563 40563 ;;
40564 40564 *)
40565 40565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40566 40566 for as_dir in $PATH
40567 40567 do
40568 40568 IFS=$as_save_IFS
40569 40569 test -z "$as_dir" && as_dir=.
40570 40570 for ac_exec_ext in '' $ac_executable_extensions; do
40571 40571 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40572 40572 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
40573 40573 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40574 40574 break 2
40575 40575 fi
40576 40576 done
40577 40577 done
40578 40578 IFS=$as_save_IFS
40579 40579
40580 40580 ;;
40581 40581 esac
40582 40582 fi
40583 40583 GNM=$ac_cv_path_GNM
40584 40584 if test -n "$GNM"; then
40585 40585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
40586 40586 $as_echo "$GNM" >&6; }
40587 40587 else
40588 40588 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40589 40589 $as_echo "no" >&6; }
40590 40590 fi
40591 40591
40592 40592
40593 40593 test -n "$GNM" && break
40594 40594 done
40595 40595
40596 40596 else
40597 40597 # The variable is set, but is it from the command line or the environment?
40598 40598
40599 40599 # Try to remove the string !GNM! from our list.
40600 40600 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GNM!/}
40601 40601 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
40602 40602 # If it failed, the variable was not from the command line. Ignore it,
40603 40603 # but warn the user (except for BASH, which is always set by the calling BASH).
40604 40604 if test "xGNM" != xBASH; then
40605 40605 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
40606 40606 $as_echo "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
40607 40607 fi
40608 40608 # Try to locate tool using the code snippet
40609 40609 for ac_prog in gnm
40610 40610 do
40611 40611 # Extract the first word of "$ac_prog", so it can be a program name with args.
40612 40612 set dummy $ac_prog; ac_word=$2
40613 40613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40614 40614 $as_echo_n "checking for $ac_word... " >&6; }
40615 40615 if ${ac_cv_path_GNM+:} false; then :
40616 40616 $as_echo_n "(cached) " >&6
40617 40617 else
40618 40618 case $GNM in
40619 40619 [\\/]* | ?:[\\/]*)
40620 40620 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
40621 40621 ;;
40622 40622 *)
40623 40623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40624 40624 for as_dir in $PATH
40625 40625 do
40626 40626 IFS=$as_save_IFS
40627 40627 test -z "$as_dir" && as_dir=.
40628 40628 for ac_exec_ext in '' $ac_executable_extensions; do
40629 40629 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40630 40630 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
40631 40631 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40632 40632 break 2
40633 40633 fi
40634 40634 done
40635 40635 done
40636 40636 IFS=$as_save_IFS
40637 40637
40638 40638 ;;
40639 40639 esac
40640 40640 fi
40641 40641 GNM=$ac_cv_path_GNM
40642 40642 if test -n "$GNM"; then
40643 40643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
40644 40644 $as_echo "$GNM" >&6; }
40645 40645 else
40646 40646 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40647 40647 $as_echo "no" >&6; }
40648 40648 fi
40649 40649
40650 40650
40651 40651 test -n "$GNM" && break
40652 40652 done
40653 40653
40654 40654 else
40655 40655 # If it succeeded, then it was overridden by the user. We will use it
40656 40656 # for the tool.
40657 40657
40658 40658 # First remove it from the list of overridden variables, so we can test
40659 40659 # for unknown variables in the end.
40660 40660 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
40661 40661
40662 40662 # Check if we try to supply an empty value
40663 40663 if test "x$GNM" = x; then
40664 40664 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GNM= (no value)" >&5
40665 40665 $as_echo "$as_me: Setting user supplied tool GNM= (no value)" >&6;}
40666 40666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
40667 40667 $as_echo_n "checking for GNM... " >&6; }
40668 40668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
40669 40669 $as_echo "disabled" >&6; }
40670 40670 else
40671 40671 # Check if the provided tool contains a complete path.
40672 40672 tool_specified="$GNM"
40673 40673 tool_basename="${tool_specified##*/}"
40674 40674 if test "x$tool_basename" = "x$tool_specified"; then
40675 40675 # A command without a complete path is provided, search $PATH.
40676 40676 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
40677 40677 $as_echo "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
40678 40678 # Extract the first word of "$tool_basename", so it can be a program name with args.
40679 40679 set dummy $tool_basename; ac_word=$2
40680 40680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
40681 40681 $as_echo_n "checking for $ac_word... " >&6; }
40682 40682 if ${ac_cv_path_GNM+:} false; then :
40683 40683 $as_echo_n "(cached) " >&6
40684 40684 else
40685 40685 case $GNM in
40686 40686 [\\/]* | ?:[\\/]*)
40687 40687 ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
40688 40688 ;;
40689 40689 *)
40690 40690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
40691 40691 for as_dir in $PATH
40692 40692 do
40693 40693 IFS=$as_save_IFS
40694 40694 test -z "$as_dir" && as_dir=.
40695 40695 for ac_exec_ext in '' $ac_executable_extensions; do
40696 40696 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
40697 40697 ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
40698 40698 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
40699 40699 break 2
40700 40700 fi
40701 40701 done
40702 40702 done
40703 40703 IFS=$as_save_IFS
40704 40704
40705 40705 ;;
40706 40706 esac
40707 40707 fi
40708 40708 GNM=$ac_cv_path_GNM
40709 40709 if test -n "$GNM"; then
40710 40710 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
40711 40711 $as_echo "$GNM" >&6; }
40712 40712 else
40713 40713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
40714 40714 $as_echo "no" >&6; }
40715 40715 fi
40716 40716
40717 40717
40718 40718 if test "x$GNM" = x; then
40719 40719 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
40720 40720 fi
40721 40721 else
40722 40722 # Otherwise we believe it is a complete path. Use it as it is.
40723 40723 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
40724 40724 $as_echo "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
40725 40725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
40726 40726 $as_echo_n "checking for GNM... " >&6; }
40727 40727 if test ! -x "$tool_specified"; then
40728 40728 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
40729 40729 $as_echo "not found" >&6; }
40730 40730 as_fn_error $? "User supplied tool GNM=$tool_specified does not exist or is not executable" "$LINENO" 5
40731 40731 fi
40732 40732 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
40733 40733 $as_echo "$tool_specified" >&6; }
40734 40734 fi
40735 40735 fi
40736 40736 fi
40737 40737
40738 40738 fi
40739 40739
40740 40740
40741 40741
40742 40742 # Only process if variable expands to non-empty
40743 40743
40744 40744 if test "x$GNM" != x; then
40745 40745 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40746 40746
40747 40747 # First separate the path from the arguments. This will split at the first
40748 40748 # space.
40749 40749 complete="$GNM"
40750 40750 path="${complete%% *}"
40751 40751 tmp="$complete EOL"
40752 40752 arguments="${tmp#* }"
40753 40753
40754 40754 # Input might be given as Windows format, start by converting to
40755 40755 # unix format.
40756 40756 new_path=`$CYGPATH -u "$path"`
40757 40757
40758 40758 # Now try to locate executable using which
40759 40759 new_path=`$WHICH "$new_path" 2> /dev/null`
40760 40760 # bat and cmd files are not always considered executable in cygwin causing which
40761 40761 # to not find them
40762 40762 if test "x$new_path" = x \
40763 40763 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40764 40764 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40765 40765 new_path=`$CYGPATH -u "$path"`
40766 40766 fi
40767 40767 if test "x$new_path" = x; then
40768 40768 # Oops. Which didn't find the executable.
40769 40769 # The splitting of arguments from the executable at a space might have been incorrect,
40770 40770 # since paths with space are more likely in Windows. Give it another try with the whole
40771 40771 # argument.
40772 40772 path="$complete"
40773 40773 arguments="EOL"
40774 40774 new_path=`$CYGPATH -u "$path"`
40775 40775 new_path=`$WHICH "$new_path" 2> /dev/null`
40776 40776 # bat and cmd files are not always considered executable in cygwin causing which
40777 40777 # to not find them
40778 40778 if test "x$new_path" = x \
40779 40779 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40780 40780 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40781 40781 new_path=`$CYGPATH -u "$path"`
40782 40782 fi
40783 40783 if test "x$new_path" = x; then
40784 40784 # It's still not found. Now this is an unrecoverable error.
40785 40785 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
40786 40786 $as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
40787 40787 has_space=`$ECHO "$complete" | $GREP " "`
40788 40788 if test "x$has_space" != x; then
40789 40789 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40790 40790 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40791 40791 fi
40792 40792 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
40793 40793 fi
40794 40794 fi
40795 40795
40796 40796 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
40797 40797 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
40798 40798 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
40799 40799 # "foo.exe" is OK but "foo" is an error.
40800 40800 #
40801 40801 # This test is therefore slightly more accurate than "test -f" to check for file presence.
40802 40802 # It is also a way to make sure we got the proper file name for the real test later on.
40803 40803 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
40804 40804 if test "x$test_shortpath" = x; then
40805 40805 # Short path failed, file does not exist as specified.
40806 40806 # Try adding .exe or .cmd
40807 40807 if test -f "${new_path}.exe"; then
40808 40808 input_to_shortpath="${new_path}.exe"
40809 40809 elif test -f "${new_path}.cmd"; then
40810 40810 input_to_shortpath="${new_path}.cmd"
40811 40811 else
40812 40812 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
40813 40813 $as_echo "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
40814 40814 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
40815 40815 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
40816 40816 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
40817 40817 fi
40818 40818 else
40819 40819 input_to_shortpath="$new_path"
40820 40820 fi
40821 40821
40822 40822 # Call helper function which possibly converts this using DOS-style short mode.
40823 40823 # If so, the updated path is stored in $new_path.
40824 40824 new_path="$input_to_shortpath"
40825 40825
40826 40826 input_path="$input_to_shortpath"
40827 40827 # Check if we need to convert this using DOS-style short mode. If the path
40828 40828 # contains just simple characters, use it. Otherwise (spaces, weird characters),
40829 40829 # take no chances and rewrite it.
40830 40830 # Note: m4 eats our [], so we need to use [ and ] instead.
40831 40831 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
40832 40832 if test "x$has_forbidden_chars" != x; then
40833 40833 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
40834 40834 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
40835 40835 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
40836 40836 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
40837 40837 # Going to short mode and back again did indeed matter. Since short mode is
40838 40838 # case insensitive, let's make it lowercase to improve readability.
40839 40839 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
40840 40840 # Now convert it back to Unix-style (cygpath)
40841 40841 input_path=`$CYGPATH -u "$shortmode_path"`
40842 40842 new_path="$input_path"
40843 40843 fi
40844 40844 fi
40845 40845
40846 40846 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
40847 40847 if test "x$test_cygdrive_prefix" = x; then
40848 40848 # As a simple fix, exclude /usr/bin since it's not a real path.
40849 40849 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
40850 40850 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
40851 40851 # a path prefixed by /cygdrive for fixpath to work.
40852 40852 new_path="$CYGWIN_ROOT_PATH$input_path"
40853 40853 fi
40854 40854 fi
40855 40855
40856 40856 # remove trailing .exe if any
40857 40857 new_path="${new_path/%.exe/}"
40858 40858
40859 40859 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40860 40860
40861 40861 # First separate the path from the arguments. This will split at the first
40862 40862 # space.
40863 40863 complete="$GNM"
40864 40864 path="${complete%% *}"
40865 40865 tmp="$complete EOL"
40866 40866 arguments="${tmp#* }"
40867 40867
40868 40868 # Input might be given as Windows format, start by converting to
40869 40869 # unix format.
40870 40870 new_path="$path"
40871 40871
40872 40872 windows_path="$new_path"
40873 40873 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40874 40874 unix_path=`$CYGPATH -u "$windows_path"`
40875 40875 new_path="$unix_path"
40876 40876 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40877 40877 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40878 40878 new_path="$unix_path"
40879 40879 fi
40880 40880
40881 40881
40882 40882 # Now try to locate executable using which
40883 40883 new_path=`$WHICH "$new_path" 2> /dev/null`
40884 40884
40885 40885 if test "x$new_path" = x; then
40886 40886 # Oops. Which didn't find the executable.
40887 40887 # The splitting of arguments from the executable at a space might have been incorrect,
40888 40888 # since paths with space are more likely in Windows. Give it another try with the whole
40889 40889 # argument.
40890 40890 path="$complete"
40891 40891 arguments="EOL"
40892 40892 new_path="$path"
40893 40893
40894 40894 windows_path="$new_path"
40895 40895 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40896 40896 unix_path=`$CYGPATH -u "$windows_path"`
40897 40897 new_path="$unix_path"
40898 40898 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40899 40899 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40900 40900 new_path="$unix_path"
40901 40901 fi
40902 40902
40903 40903
40904 40904 new_path=`$WHICH "$new_path" 2> /dev/null`
40905 40905 # bat and cmd files are not always considered executable in MSYS causing which
40906 40906 # to not find them
40907 40907 if test "x$new_path" = x \
40908 40908 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
40909 40909 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
40910 40910 new_path="$path"
40911 40911
40912 40912 windows_path="$new_path"
40913 40913 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40914 40914 unix_path=`$CYGPATH -u "$windows_path"`
40915 40915 new_path="$unix_path"
40916 40916 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40917 40917 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40918 40918 new_path="$unix_path"
40919 40919 fi
40920 40920
40921 40921 fi
40922 40922
40923 40923 if test "x$new_path" = x; then
40924 40924 # It's still not found. Now this is an unrecoverable error.
40925 40925 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
40926 40926 $as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
40927 40927 has_space=`$ECHO "$complete" | $GREP " "`
40928 40928 if test "x$has_space" != x; then
40929 40929 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
40930 40930 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
40931 40931 fi
40932 40932 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
40933 40933 fi
40934 40934 fi
40935 40935
40936 40936 # Now new_path has a complete unix path to the binary
40937 40937 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
40938 40938 # Keep paths in /bin as-is, but remove trailing .exe if any
40939 40939 new_path="${new_path/%.exe/}"
40940 40940 # Do not save /bin paths to all_fixpath_prefixes!
40941 40941 else
40942 40942 # Not in mixed or Windows style, start by that.
40943 40943 new_path=`cmd //c echo $new_path`
40944 40944
40945 40945 input_path="$new_path"
40946 40946 # Check if we need to convert this using DOS-style short mode. If the path
40947 40947 # contains just simple characters, use it. Otherwise (spaces, weird characters),
40948 40948 # take no chances and rewrite it.
40949 40949 # Note: m4 eats our [], so we need to use [ and ] instead.
40950 40950 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
40951 40951 if test "x$has_forbidden_chars" != x; then
40952 40952 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
40953 40953 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
40954 40954 fi
40955 40955
40956 40956 # Output is in $new_path
40957 40957
40958 40958 windows_path="$new_path"
40959 40959 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40960 40960 unix_path=`$CYGPATH -u "$windows_path"`
40961 40961 new_path="$unix_path"
40962 40962 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40963 40963 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40964 40964 new_path="$unix_path"
40965 40965 fi
40966 40966
40967 40967 # remove trailing .exe if any
40968 40968 new_path="${new_path/%.exe/}"
40969 40969
40970 40970 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40971 40971 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40972 40972 fi
40973 40973
40974 40974 else
40975 40975 # We're on a unix platform. Hooray! :)
40976 40976 # First separate the path from the arguments. This will split at the first
40977 40977 # space.
40978 40978 complete="$GNM"
40979 40979 path="${complete%% *}"
40980 40980 tmp="$complete EOL"
40981 40981 arguments="${tmp#* }"
40982 40982
40983 40983 # Cannot rely on the command "which" here since it doesn't always work.
40984 40984 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40985 40985 if test -z "$is_absolute_path"; then
40986 40986 # Path to executable is not absolute. Find it.
40987 40987 IFS_save="$IFS"
40988 40988 IFS=:
40989 40989 for p in $PATH; do
40990 40990 if test -f "$p/$path" && test -x "$p/$path"; then
40991 40991 new_path="$p/$path"
40992 40992 break
40993 40993 fi
40994 40994 done
40995 40995 IFS="$IFS_save"
40996 40996 else
40997 40997 # This is an absolute path, we can use it without further modifications.
40998 40998 new_path="$path"
40999 40999 fi
41000 41000
41001 41001 if test "x$new_path" = x; then
41002 41002 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
41003 41003 $as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
41004 41004 has_space=`$ECHO "$complete" | $GREP " "`
41005 41005 if test "x$has_space" != x; then
41006 41006 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
41007 41007 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
41008 41008 fi
41009 41009 as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
41010 41010 fi
41011 41011 fi
41012 41012
41013 41013 # Now join together the path and the arguments once again
41014 41014 if test "x$arguments" != xEOL; then
41015 41015 new_complete="$new_path ${arguments% *}"
41016 41016 else
41017 41017 new_complete="$new_path"
41018 41018 fi
41019 41019
41020 41020 if test "x$complete" != "x$new_complete"; then
41021 41021 GNM="$new_complete"
41022 41022 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
41023 41023 $as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
41024 41024 fi
41025 41025 fi
41026 41026
41027 41027 elif test "x$OPENJDK_TARGET_OS" != xwindows; then
41028 41028 # FIXME: we should unify this with the solaris case above.
41029 41029
41030 41030
41031 41031 # Publish this variable in the help.
41032 41032
41033 41033
41034 41034 if [ -z "${STRIP+x}" ]; then
41035 41035 # The variable is not set by user, try to locate tool using the code snippet
41036 41036 if test -n "$ac_tool_prefix"; then
41037 41037 for ac_prog in strip
41038 41038 do
41039 41039 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
41040 41040 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
41041 41041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41042 41042 $as_echo_n "checking for $ac_word... " >&6; }
41043 41043 if ${ac_cv_prog_STRIP+:} false; then :
41044 41044 $as_echo_n "(cached) " >&6
41045 41045 else
41046 41046 if test -n "$STRIP"; then
41047 41047 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
41048 41048 else
41049 41049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41050 41050 for as_dir in $PATH
41051 41051 do
41052 41052 IFS=$as_save_IFS
41053 41053 test -z "$as_dir" && as_dir=.
41054 41054 for ac_exec_ext in '' $ac_executable_extensions; do
41055 41055 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41056 41056 ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
41057 41057 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41058 41058 break 2
41059 41059 fi
41060 41060 done
41061 41061 done
41062 41062 IFS=$as_save_IFS
41063 41063
41064 41064 fi
41065 41065 fi
41066 41066 STRIP=$ac_cv_prog_STRIP
41067 41067 if test -n "$STRIP"; then
41068 41068 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
41069 41069 $as_echo "$STRIP" >&6; }
41070 41070 else
41071 41071 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41072 41072 $as_echo "no" >&6; }
41073 41073 fi
41074 41074
41075 41075
41076 41076 test -n "$STRIP" && break
41077 41077 done
41078 41078 fi
41079 41079 if test -z "$STRIP"; then
41080 41080 ac_ct_STRIP=$STRIP
41081 41081 for ac_prog in strip
41082 41082 do
41083 41083 # Extract the first word of "$ac_prog", so it can be a program name with args.
41084 41084 set dummy $ac_prog; ac_word=$2
41085 41085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41086 41086 $as_echo_n "checking for $ac_word... " >&6; }
41087 41087 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
41088 41088 $as_echo_n "(cached) " >&6
41089 41089 else
41090 41090 if test -n "$ac_ct_STRIP"; then
41091 41091 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
41092 41092 else
41093 41093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41094 41094 for as_dir in $PATH
41095 41095 do
41096 41096 IFS=$as_save_IFS
41097 41097 test -z "$as_dir" && as_dir=.
41098 41098 for ac_exec_ext in '' $ac_executable_extensions; do
41099 41099 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41100 41100 ac_cv_prog_ac_ct_STRIP="$ac_prog"
41101 41101 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41102 41102 break 2
41103 41103 fi
41104 41104 done
41105 41105 done
41106 41106 IFS=$as_save_IFS
41107 41107
41108 41108 fi
41109 41109 fi
41110 41110 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
41111 41111 if test -n "$ac_ct_STRIP"; then
41112 41112 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
41113 41113 $as_echo "$ac_ct_STRIP" >&6; }
41114 41114 else
41115 41115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41116 41116 $as_echo "no" >&6; }
41117 41117 fi
41118 41118
41119 41119
41120 41120 test -n "$ac_ct_STRIP" && break
41121 41121 done
41122 41122
41123 41123 if test "x$ac_ct_STRIP" = x; then
41124 41124 STRIP=""
41125 41125 else
41126 41126 case $cross_compiling:$ac_tool_warned in
41127 41127 yes:)
41128 41128 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
41129 41129 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
41130 41130 ac_tool_warned=yes ;;
41131 41131 esac
41132 41132 STRIP=$ac_ct_STRIP
41133 41133 fi
41134 41134 fi
41135 41135
41136 41136 else
41137 41137 # The variable is set, but is it from the command line or the environment?
41138 41138
41139 41139 # Try to remove the string !STRIP! from our list.
41140 41140 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
41141 41141 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
41142 41142 # If it failed, the variable was not from the command line. Ignore it,
41143 41143 # but warn the user (except for BASH, which is always set by the calling BASH).
41144 41144 if test "xSTRIP" != xBASH; then
41145 41145 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
41146 41146 $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
41147 41147 fi
41148 41148 # Try to locate tool using the code snippet
41149 41149 if test -n "$ac_tool_prefix"; then
41150 41150 for ac_prog in strip
41151 41151 do
41152 41152 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
41153 41153 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
41154 41154 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41155 41155 $as_echo_n "checking for $ac_word... " >&6; }
41156 41156 if ${ac_cv_prog_STRIP+:} false; then :
41157 41157 $as_echo_n "(cached) " >&6
41158 41158 else
41159 41159 if test -n "$STRIP"; then
41160 41160 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
41161 41161 else
41162 41162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41163 41163 for as_dir in $PATH
41164 41164 do
41165 41165 IFS=$as_save_IFS
41166 41166 test -z "$as_dir" && as_dir=.
41167 41167 for ac_exec_ext in '' $ac_executable_extensions; do
41168 41168 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41169 41169 ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
41170 41170 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41171 41171 break 2
41172 41172 fi
41173 41173 done
41174 41174 done
41175 41175 IFS=$as_save_IFS
41176 41176
41177 41177 fi
41178 41178 fi
41179 41179 STRIP=$ac_cv_prog_STRIP
41180 41180 if test -n "$STRIP"; then
41181 41181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
41182 41182 $as_echo "$STRIP" >&6; }
41183 41183 else
41184 41184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41185 41185 $as_echo "no" >&6; }
41186 41186 fi
41187 41187
41188 41188
41189 41189 test -n "$STRIP" && break
41190 41190 done
41191 41191 fi
41192 41192 if test -z "$STRIP"; then
41193 41193 ac_ct_STRIP=$STRIP
41194 41194 for ac_prog in strip
41195 41195 do
41196 41196 # Extract the first word of "$ac_prog", so it can be a program name with args.
41197 41197 set dummy $ac_prog; ac_word=$2
41198 41198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41199 41199 $as_echo_n "checking for $ac_word... " >&6; }
41200 41200 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
41201 41201 $as_echo_n "(cached) " >&6
41202 41202 else
41203 41203 if test -n "$ac_ct_STRIP"; then
41204 41204 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
41205 41205 else
41206 41206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41207 41207 for as_dir in $PATH
41208 41208 do
41209 41209 IFS=$as_save_IFS
41210 41210 test -z "$as_dir" && as_dir=.
41211 41211 for ac_exec_ext in '' $ac_executable_extensions; do
41212 41212 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41213 41213 ac_cv_prog_ac_ct_STRIP="$ac_prog"
41214 41214 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41215 41215 break 2
41216 41216 fi
41217 41217 done
41218 41218 done
41219 41219 IFS=$as_save_IFS
41220 41220
41221 41221 fi
41222 41222 fi
41223 41223 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
41224 41224 if test -n "$ac_ct_STRIP"; then
41225 41225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
41226 41226 $as_echo "$ac_ct_STRIP" >&6; }
41227 41227 else
41228 41228 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41229 41229 $as_echo "no" >&6; }
41230 41230 fi
41231 41231
41232 41232
41233 41233 test -n "$ac_ct_STRIP" && break
41234 41234 done
41235 41235
41236 41236 if test "x$ac_ct_STRIP" = x; then
41237 41237 STRIP=""
41238 41238 else
41239 41239 case $cross_compiling:$ac_tool_warned in
41240 41240 yes:)
41241 41241 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
41242 41242 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
41243 41243 ac_tool_warned=yes ;;
41244 41244 esac
41245 41245 STRIP=$ac_ct_STRIP
41246 41246 fi
41247 41247 fi
41248 41248
41249 41249 else
41250 41250 # If it succeeded, then it was overridden by the user. We will use it
41251 41251 # for the tool.
41252 41252
41253 41253 # First remove it from the list of overridden variables, so we can test
41254 41254 # for unknown variables in the end.
41255 41255 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
41256 41256
41257 41257 # Check if we try to supply an empty value
41258 41258 if test "x$STRIP" = x; then
41259 41259 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STRIP= (no value)" >&5
41260 41260 $as_echo "$as_me: Setting user supplied tool STRIP= (no value)" >&6;}
41261 41261 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
41262 41262 $as_echo_n "checking for STRIP... " >&6; }
41263 41263 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
41264 41264 $as_echo "disabled" >&6; }
41265 41265 else
41266 41266 # Check if the provided tool contains a complete path.
41267 41267 tool_specified="$STRIP"
41268 41268 tool_basename="${tool_specified##*/}"
41269 41269 if test "x$tool_basename" = "x$tool_specified"; then
41270 41270 # A command without a complete path is provided, search $PATH.
41271 41271 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
41272 41272 $as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
41273 41273 # Extract the first word of "$tool_basename", so it can be a program name with args.
41274 41274 set dummy $tool_basename; ac_word=$2
41275 41275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41276 41276 $as_echo_n "checking for $ac_word... " >&6; }
41277 41277 if ${ac_cv_path_STRIP+:} false; then :
41278 41278 $as_echo_n "(cached) " >&6
41279 41279 else
41280 41280 case $STRIP in
41281 41281 [\\/]* | ?:[\\/]*)
41282 41282 ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
41283 41283 ;;
41284 41284 *)
41285 41285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41286 41286 for as_dir in $PATH
41287 41287 do
41288 41288 IFS=$as_save_IFS
41289 41289 test -z "$as_dir" && as_dir=.
41290 41290 for ac_exec_ext in '' $ac_executable_extensions; do
41291 41291 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41292 41292 ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
41293 41293 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41294 41294 break 2
41295 41295 fi
41296 41296 done
41297 41297 done
41298 41298 IFS=$as_save_IFS
41299 41299
41300 41300 ;;
41301 41301 esac
41302 41302 fi
41303 41303 STRIP=$ac_cv_path_STRIP
41304 41304 if test -n "$STRIP"; then
41305 41305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
41306 41306 $as_echo "$STRIP" >&6; }
41307 41307 else
41308 41308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41309 41309 $as_echo "no" >&6; }
41310 41310 fi
41311 41311
41312 41312
41313 41313 if test "x$STRIP" = x; then
41314 41314 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
41315 41315 fi
41316 41316 else
41317 41317 # Otherwise we believe it is a complete path. Use it as it is.
41318 41318 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
41319 41319 $as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
41320 41320 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
41321 41321 $as_echo_n "checking for STRIP... " >&6; }
41322 41322 if test ! -x "$tool_specified"; then
41323 41323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
41324 41324 $as_echo "not found" >&6; }
41325 41325 as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
41326 41326 fi
41327 41327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
41328 41328 $as_echo "$tool_specified" >&6; }
41329 41329 fi
41330 41330 fi
41331 41331 fi
41332 41332
41333 41333 fi
41334 41334
41335 41335
41336 41336
41337 41337 # Only process if variable expands to non-empty
41338 41338
41339 41339 if test "x$STRIP" != x; then
41340 41340 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41341 41341
41342 41342 # First separate the path from the arguments. This will split at the first
41343 41343 # space.
41344 41344 complete="$STRIP"
41345 41345 path="${complete%% *}"
41346 41346 tmp="$complete EOL"
41347 41347 arguments="${tmp#* }"
41348 41348
41349 41349 # Input might be given as Windows format, start by converting to
41350 41350 # unix format.
41351 41351 new_path=`$CYGPATH -u "$path"`
41352 41352
41353 41353 # Now try to locate executable using which
41354 41354 new_path=`$WHICH "$new_path" 2> /dev/null`
41355 41355 # bat and cmd files are not always considered executable in cygwin causing which
41356 41356 # to not find them
41357 41357 if test "x$new_path" = x \
41358 41358 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
41359 41359 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
41360 41360 new_path=`$CYGPATH -u "$path"`
41361 41361 fi
41362 41362 if test "x$new_path" = x; then
41363 41363 # Oops. Which didn't find the executable.
41364 41364 # The splitting of arguments from the executable at a space might have been incorrect,
41365 41365 # since paths with space are more likely in Windows. Give it another try with the whole
41366 41366 # argument.
41367 41367 path="$complete"
41368 41368 arguments="EOL"
41369 41369 new_path=`$CYGPATH -u "$path"`
41370 41370 new_path=`$WHICH "$new_path" 2> /dev/null`
41371 41371 # bat and cmd files are not always considered executable in cygwin causing which
41372 41372 # to not find them
41373 41373 if test "x$new_path" = x \
41374 41374 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
41375 41375 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
41376 41376 new_path=`$CYGPATH -u "$path"`
41377 41377 fi
41378 41378 if test "x$new_path" = x; then
41379 41379 # It's still not found. Now this is an unrecoverable error.
41380 41380 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
41381 41381 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
41382 41382 has_space=`$ECHO "$complete" | $GREP " "`
41383 41383 if test "x$has_space" != x; then
41384 41384 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
41385 41385 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
41386 41386 fi
41387 41387 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
41388 41388 fi
41389 41389 fi
41390 41390
41391 41391 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
41392 41392 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
41393 41393 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
41394 41394 # "foo.exe" is OK but "foo" is an error.
41395 41395 #
41396 41396 # This test is therefore slightly more accurate than "test -f" to check for file presence.
41397 41397 # It is also a way to make sure we got the proper file name for the real test later on.
41398 41398 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
41399 41399 if test "x$test_shortpath" = x; then
41400 41400 # Short path failed, file does not exist as specified.
41401 41401 # Try adding .exe or .cmd
41402 41402 if test -f "${new_path}.exe"; then
41403 41403 input_to_shortpath="${new_path}.exe"
41404 41404 elif test -f "${new_path}.cmd"; then
41405 41405 input_to_shortpath="${new_path}.cmd"
41406 41406 else
41407 41407 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
41408 41408 $as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
41409 41409 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
41410 41410 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
41411 41411 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
41412 41412 fi
41413 41413 else
41414 41414 input_to_shortpath="$new_path"
41415 41415 fi
41416 41416
41417 41417 # Call helper function which possibly converts this using DOS-style short mode.
41418 41418 # If so, the updated path is stored in $new_path.
41419 41419 new_path="$input_to_shortpath"
41420 41420
41421 41421 input_path="$input_to_shortpath"
41422 41422 # Check if we need to convert this using DOS-style short mode. If the path
41423 41423 # contains just simple characters, use it. Otherwise (spaces, weird characters),
41424 41424 # take no chances and rewrite it.
41425 41425 # Note: m4 eats our [], so we need to use [ and ] instead.
41426 41426 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
41427 41427 if test "x$has_forbidden_chars" != x; then
41428 41428 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
41429 41429 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
41430 41430 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
41431 41431 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
41432 41432 # Going to short mode and back again did indeed matter. Since short mode is
41433 41433 # case insensitive, let's make it lowercase to improve readability.
41434 41434 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
41435 41435 # Now convert it back to Unix-style (cygpath)
41436 41436 input_path=`$CYGPATH -u "$shortmode_path"`
41437 41437 new_path="$input_path"
41438 41438 fi
41439 41439 fi
41440 41440
41441 41441 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
41442 41442 if test "x$test_cygdrive_prefix" = x; then
41443 41443 # As a simple fix, exclude /usr/bin since it's not a real path.
41444 41444 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
41445 41445 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
41446 41446 # a path prefixed by /cygdrive for fixpath to work.
41447 41447 new_path="$CYGWIN_ROOT_PATH$input_path"
41448 41448 fi
41449 41449 fi
41450 41450
41451 41451 # remove trailing .exe if any
41452 41452 new_path="${new_path/%.exe/}"
41453 41453
41454 41454 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41455 41455
41456 41456 # First separate the path from the arguments. This will split at the first
41457 41457 # space.
41458 41458 complete="$STRIP"
41459 41459 path="${complete%% *}"
41460 41460 tmp="$complete EOL"
41461 41461 arguments="${tmp#* }"
41462 41462
41463 41463 # Input might be given as Windows format, start by converting to
41464 41464 # unix format.
41465 41465 new_path="$path"
41466 41466
41467 41467 windows_path="$new_path"
41468 41468 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41469 41469 unix_path=`$CYGPATH -u "$windows_path"`
41470 41470 new_path="$unix_path"
41471 41471 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41472 41472 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41473 41473 new_path="$unix_path"
41474 41474 fi
41475 41475
41476 41476
41477 41477 # Now try to locate executable using which
41478 41478 new_path=`$WHICH "$new_path" 2> /dev/null`
41479 41479
41480 41480 if test "x$new_path" = x; then
41481 41481 # Oops. Which didn't find the executable.
41482 41482 # The splitting of arguments from the executable at a space might have been incorrect,
41483 41483 # since paths with space are more likely in Windows. Give it another try with the whole
41484 41484 # argument.
41485 41485 path="$complete"
41486 41486 arguments="EOL"
41487 41487 new_path="$path"
41488 41488
41489 41489 windows_path="$new_path"
41490 41490 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41491 41491 unix_path=`$CYGPATH -u "$windows_path"`
41492 41492 new_path="$unix_path"
41493 41493 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41494 41494 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41495 41495 new_path="$unix_path"
41496 41496 fi
41497 41497
41498 41498
41499 41499 new_path=`$WHICH "$new_path" 2> /dev/null`
41500 41500 # bat and cmd files are not always considered executable in MSYS causing which
41501 41501 # to not find them
41502 41502 if test "x$new_path" = x \
41503 41503 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
41504 41504 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
41505 41505 new_path="$path"
41506 41506
41507 41507 windows_path="$new_path"
41508 41508 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41509 41509 unix_path=`$CYGPATH -u "$windows_path"`
41510 41510 new_path="$unix_path"
41511 41511 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41512 41512 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41513 41513 new_path="$unix_path"
41514 41514 fi
41515 41515
41516 41516 fi
41517 41517
41518 41518 if test "x$new_path" = x; then
41519 41519 # It's still not found. Now this is an unrecoverable error.
41520 41520 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
41521 41521 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
41522 41522 has_space=`$ECHO "$complete" | $GREP " "`
41523 41523 if test "x$has_space" != x; then
41524 41524 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
41525 41525 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
41526 41526 fi
41527 41527 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
41528 41528 fi
41529 41529 fi
41530 41530
41531 41531 # Now new_path has a complete unix path to the binary
41532 41532 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
41533 41533 # Keep paths in /bin as-is, but remove trailing .exe if any
41534 41534 new_path="${new_path/%.exe/}"
41535 41535 # Do not save /bin paths to all_fixpath_prefixes!
41536 41536 else
41537 41537 # Not in mixed or Windows style, start by that.
41538 41538 new_path=`cmd //c echo $new_path`
41539 41539
41540 41540 input_path="$new_path"
41541 41541 # Check if we need to convert this using DOS-style short mode. If the path
41542 41542 # contains just simple characters, use it. Otherwise (spaces, weird characters),
41543 41543 # take no chances and rewrite it.
41544 41544 # Note: m4 eats our [], so we need to use [ and ] instead.
41545 41545 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
41546 41546 if test "x$has_forbidden_chars" != x; then
41547 41547 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
41548 41548 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
41549 41549 fi
41550 41550
41551 41551 # Output is in $new_path
41552 41552
41553 41553 windows_path="$new_path"
41554 41554 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41555 41555 unix_path=`$CYGPATH -u "$windows_path"`
41556 41556 new_path="$unix_path"
41557 41557 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41558 41558 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41559 41559 new_path="$unix_path"
41560 41560 fi
41561 41561
41562 41562 # remove trailing .exe if any
41563 41563 new_path="${new_path/%.exe/}"
41564 41564
41565 41565 # Save the first 10 bytes of this path to the storage, so fixpath can work.
41566 41566 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
41567 41567 fi
41568 41568
41569 41569 else
41570 41570 # We're on a unix platform. Hooray! :)
41571 41571 # First separate the path from the arguments. This will split at the first
41572 41572 # space.
41573 41573 complete="$STRIP"
41574 41574 path="${complete%% *}"
41575 41575 tmp="$complete EOL"
41576 41576 arguments="${tmp#* }"
41577 41577
41578 41578 # Cannot rely on the command "which" here since it doesn't always work.
41579 41579 is_absolute_path=`$ECHO "$path" | $GREP ^/`
41580 41580 if test -z "$is_absolute_path"; then
41581 41581 # Path to executable is not absolute. Find it.
41582 41582 IFS_save="$IFS"
41583 41583 IFS=:
41584 41584 for p in $PATH; do
41585 41585 if test -f "$p/$path" && test -x "$p/$path"; then
41586 41586 new_path="$p/$path"
41587 41587 break
41588 41588 fi
41589 41589 done
41590 41590 IFS="$IFS_save"
41591 41591 else
41592 41592 # This is an absolute path, we can use it without further modifications.
41593 41593 new_path="$path"
41594 41594 fi
41595 41595
41596 41596 if test "x$new_path" = x; then
41597 41597 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
41598 41598 $as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
41599 41599 has_space=`$ECHO "$complete" | $GREP " "`
41600 41600 if test "x$has_space" != x; then
41601 41601 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
41602 41602 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
41603 41603 fi
41604 41604 as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
41605 41605 fi
41606 41606 fi
41607 41607
41608 41608 # Now join together the path and the arguments once again
41609 41609 if test "x$arguments" != xEOL; then
41610 41610 new_complete="$new_path ${arguments% *}"
41611 41611 else
41612 41612 new_complete="$new_path"
41613 41613 fi
41614 41614
41615 41615 if test "x$complete" != "x$new_complete"; then
41616 41616 STRIP="$new_complete"
41617 41617 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
41618 41618 $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
41619 41619 fi
41620 41620 fi
41621 41621
41622 41622 if test "x$TOOLCHAIN_TYPE" = xgcc; then
41623 41623
41624 41624
41625 41625 # Publish this variable in the help.
41626 41626
41627 41627
41628 41628 if [ -z "${NM+x}" ]; then
41629 41629 # The variable is not set by user, try to locate tool using the code snippet
41630 41630 if test -n "$ac_tool_prefix"; then
41631 41631 for ac_prog in nm gcc-nm
41632 41632 do
41633 41633 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
41634 41634 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
41635 41635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41636 41636 $as_echo_n "checking for $ac_word... " >&6; }
41637 41637 if ${ac_cv_prog_NM+:} false; then :
41638 41638 $as_echo_n "(cached) " >&6
41639 41639 else
41640 41640 if test -n "$NM"; then
41641 41641 ac_cv_prog_NM="$NM" # Let the user override the test.
41642 41642 else
41643 41643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41644 41644 for as_dir in $PATH
41645 41645 do
41646 41646 IFS=$as_save_IFS
41647 41647 test -z "$as_dir" && as_dir=.
41648 41648 for ac_exec_ext in '' $ac_executable_extensions; do
41649 41649 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41650 41650 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
41651 41651 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41652 41652 break 2
41653 41653 fi
41654 41654 done
41655 41655 done
41656 41656 IFS=$as_save_IFS
41657 41657
41658 41658 fi
41659 41659 fi
41660 41660 NM=$ac_cv_prog_NM
41661 41661 if test -n "$NM"; then
41662 41662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
41663 41663 $as_echo "$NM" >&6; }
41664 41664 else
41665 41665 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41666 41666 $as_echo "no" >&6; }
41667 41667 fi
41668 41668
41669 41669
41670 41670 test -n "$NM" && break
41671 41671 done
41672 41672 fi
41673 41673 if test -z "$NM"; then
41674 41674 ac_ct_NM=$NM
41675 41675 for ac_prog in nm gcc-nm
41676 41676 do
41677 41677 # Extract the first word of "$ac_prog", so it can be a program name with args.
41678 41678 set dummy $ac_prog; ac_word=$2
41679 41679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41680 41680 $as_echo_n "checking for $ac_word... " >&6; }
41681 41681 if ${ac_cv_prog_ac_ct_NM+:} false; then :
41682 41682 $as_echo_n "(cached) " >&6
41683 41683 else
41684 41684 if test -n "$ac_ct_NM"; then
41685 41685 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
41686 41686 else
41687 41687 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41688 41688 for as_dir in $PATH
41689 41689 do
41690 41690 IFS=$as_save_IFS
41691 41691 test -z "$as_dir" && as_dir=.
41692 41692 for ac_exec_ext in '' $ac_executable_extensions; do
41693 41693 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41694 41694 ac_cv_prog_ac_ct_NM="$ac_prog"
41695 41695 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41696 41696 break 2
41697 41697 fi
41698 41698 done
41699 41699 done
41700 41700 IFS=$as_save_IFS
41701 41701
41702 41702 fi
41703 41703 fi
41704 41704 ac_ct_NM=$ac_cv_prog_ac_ct_NM
41705 41705 if test -n "$ac_ct_NM"; then
41706 41706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
41707 41707 $as_echo "$ac_ct_NM" >&6; }
41708 41708 else
41709 41709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41710 41710 $as_echo "no" >&6; }
41711 41711 fi
41712 41712
41713 41713
41714 41714 test -n "$ac_ct_NM" && break
41715 41715 done
41716 41716
41717 41717 if test "x$ac_ct_NM" = x; then
41718 41718 NM=""
41719 41719 else
41720 41720 case $cross_compiling:$ac_tool_warned in
41721 41721 yes:)
41722 41722 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
41723 41723 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
41724 41724 ac_tool_warned=yes ;;
41725 41725 esac
41726 41726 NM=$ac_ct_NM
41727 41727 fi
41728 41728 fi
41729 41729
41730 41730 else
41731 41731 # The variable is set, but is it from the command line or the environment?
41732 41732
41733 41733 # Try to remove the string !NM! from our list.
41734 41734 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
41735 41735 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
41736 41736 # If it failed, the variable was not from the command line. Ignore it,
41737 41737 # but warn the user (except for BASH, which is always set by the calling BASH).
41738 41738 if test "xNM" != xBASH; then
41739 41739 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
41740 41740 $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
41741 41741 fi
41742 41742 # Try to locate tool using the code snippet
41743 41743 if test -n "$ac_tool_prefix"; then
41744 41744 for ac_prog in nm gcc-nm
41745 41745 do
41746 41746 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
41747 41747 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
41748 41748 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41749 41749 $as_echo_n "checking for $ac_word... " >&6; }
41750 41750 if ${ac_cv_prog_NM+:} false; then :
41751 41751 $as_echo_n "(cached) " >&6
41752 41752 else
41753 41753 if test -n "$NM"; then
41754 41754 ac_cv_prog_NM="$NM" # Let the user override the test.
41755 41755 else
41756 41756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41757 41757 for as_dir in $PATH
41758 41758 do
41759 41759 IFS=$as_save_IFS
41760 41760 test -z "$as_dir" && as_dir=.
41761 41761 for ac_exec_ext in '' $ac_executable_extensions; do
41762 41762 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41763 41763 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
41764 41764 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41765 41765 break 2
41766 41766 fi
41767 41767 done
41768 41768 done
41769 41769 IFS=$as_save_IFS
41770 41770
41771 41771 fi
41772 41772 fi
41773 41773 NM=$ac_cv_prog_NM
41774 41774 if test -n "$NM"; then
41775 41775 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
41776 41776 $as_echo "$NM" >&6; }
41777 41777 else
41778 41778 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41779 41779 $as_echo "no" >&6; }
41780 41780 fi
41781 41781
41782 41782
41783 41783 test -n "$NM" && break
41784 41784 done
41785 41785 fi
41786 41786 if test -z "$NM"; then
41787 41787 ac_ct_NM=$NM
41788 41788 for ac_prog in nm gcc-nm
41789 41789 do
41790 41790 # Extract the first word of "$ac_prog", so it can be a program name with args.
41791 41791 set dummy $ac_prog; ac_word=$2
41792 41792 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41793 41793 $as_echo_n "checking for $ac_word... " >&6; }
41794 41794 if ${ac_cv_prog_ac_ct_NM+:} false; then :
41795 41795 $as_echo_n "(cached) " >&6
41796 41796 else
41797 41797 if test -n "$ac_ct_NM"; then
41798 41798 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
41799 41799 else
41800 41800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41801 41801 for as_dir in $PATH
41802 41802 do
41803 41803 IFS=$as_save_IFS
41804 41804 test -z "$as_dir" && as_dir=.
41805 41805 for ac_exec_ext in '' $ac_executable_extensions; do
41806 41806 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41807 41807 ac_cv_prog_ac_ct_NM="$ac_prog"
41808 41808 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41809 41809 break 2
41810 41810 fi
41811 41811 done
41812 41812 done
41813 41813 IFS=$as_save_IFS
41814 41814
41815 41815 fi
41816 41816 fi
41817 41817 ac_ct_NM=$ac_cv_prog_ac_ct_NM
41818 41818 if test -n "$ac_ct_NM"; then
41819 41819 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
41820 41820 $as_echo "$ac_ct_NM" >&6; }
41821 41821 else
41822 41822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41823 41823 $as_echo "no" >&6; }
41824 41824 fi
41825 41825
41826 41826
41827 41827 test -n "$ac_ct_NM" && break
41828 41828 done
41829 41829
41830 41830 if test "x$ac_ct_NM" = x; then
41831 41831 NM=""
41832 41832 else
41833 41833 case $cross_compiling:$ac_tool_warned in
41834 41834 yes:)
41835 41835 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
41836 41836 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
41837 41837 ac_tool_warned=yes ;;
41838 41838 esac
41839 41839 NM=$ac_ct_NM
41840 41840 fi
41841 41841 fi
41842 41842
41843 41843 else
41844 41844 # If it succeeded, then it was overridden by the user. We will use it
41845 41845 # for the tool.
41846 41846
41847 41847 # First remove it from the list of overridden variables, so we can test
41848 41848 # for unknown variables in the end.
41849 41849 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
41850 41850
41851 41851 # Check if we try to supply an empty value
41852 41852 if test "x$NM" = x; then
41853 41853 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
41854 41854 $as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
41855 41855 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
41856 41856 $as_echo_n "checking for NM... " >&6; }
41857 41857 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
41858 41858 $as_echo "disabled" >&6; }
41859 41859 else
41860 41860 # Check if the provided tool contains a complete path.
41861 41861 tool_specified="$NM"
41862 41862 tool_basename="${tool_specified##*/}"
41863 41863 if test "x$tool_basename" = "x$tool_specified"; then
41864 41864 # A command without a complete path is provided, search $PATH.
41865 41865 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
41866 41866 $as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
41867 41867 # Extract the first word of "$tool_basename", so it can be a program name with args.
41868 41868 set dummy $tool_basename; ac_word=$2
41869 41869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41870 41870 $as_echo_n "checking for $ac_word... " >&6; }
41871 41871 if ${ac_cv_path_NM+:} false; then :
41872 41872 $as_echo_n "(cached) " >&6
41873 41873 else
41874 41874 case $NM in
41875 41875 [\\/]* | ?:[\\/]*)
41876 41876 ac_cv_path_NM="$NM" # Let the user override the test with a path.
41877 41877 ;;
41878 41878 *)
41879 41879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41880 41880 for as_dir in $PATH
41881 41881 do
41882 41882 IFS=$as_save_IFS
41883 41883 test -z "$as_dir" && as_dir=.
41884 41884 for ac_exec_ext in '' $ac_executable_extensions; do
41885 41885 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41886 41886 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
41887 41887 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41888 41888 break 2
41889 41889 fi
41890 41890 done
41891 41891 done
41892 41892 IFS=$as_save_IFS
41893 41893
41894 41894 ;;
41895 41895 esac
41896 41896 fi
41897 41897 NM=$ac_cv_path_NM
41898 41898 if test -n "$NM"; then
41899 41899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
41900 41900 $as_echo "$NM" >&6; }
41901 41901 else
41902 41902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41903 41903 $as_echo "no" >&6; }
41904 41904 fi
41905 41905
41906 41906
41907 41907 if test "x$NM" = x; then
41908 41908 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
41909 41909 fi
41910 41910 else
41911 41911 # Otherwise we believe it is a complete path. Use it as it is.
41912 41912 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
41913 41913 $as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
41914 41914 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
41915 41915 $as_echo_n "checking for NM... " >&6; }
41916 41916 if test ! -x "$tool_specified"; then
41917 41917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
41918 41918 $as_echo "not found" >&6; }
41919 41919 as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
41920 41920 fi
41921 41921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
41922 41922 $as_echo "$tool_specified" >&6; }
41923 41923 fi
41924 41924 fi
41925 41925 fi
41926 41926
41927 41927 fi
41928 41928
41929 41929
41930 41930 else
41931 41931
41932 41932
41933 41933 # Publish this variable in the help.
41934 41934
41935 41935
41936 41936 if [ -z "${NM+x}" ]; then
41937 41937 # The variable is not set by user, try to locate tool using the code snippet
41938 41938 if test -n "$ac_tool_prefix"; then
41939 41939 for ac_prog in nm
41940 41940 do
41941 41941 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
41942 41942 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
41943 41943 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41944 41944 $as_echo_n "checking for $ac_word... " >&6; }
41945 41945 if ${ac_cv_prog_NM+:} false; then :
41946 41946 $as_echo_n "(cached) " >&6
41947 41947 else
41948 41948 if test -n "$NM"; then
41949 41949 ac_cv_prog_NM="$NM" # Let the user override the test.
41950 41950 else
41951 41951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41952 41952 for as_dir in $PATH
41953 41953 do
41954 41954 IFS=$as_save_IFS
41955 41955 test -z "$as_dir" && as_dir=.
41956 41956 for ac_exec_ext in '' $ac_executable_extensions; do
41957 41957 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
41958 41958 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
41959 41959 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
41960 41960 break 2
41961 41961 fi
41962 41962 done
41963 41963 done
41964 41964 IFS=$as_save_IFS
41965 41965
41966 41966 fi
41967 41967 fi
41968 41968 NM=$ac_cv_prog_NM
41969 41969 if test -n "$NM"; then
41970 41970 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
41971 41971 $as_echo "$NM" >&6; }
41972 41972 else
41973 41973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
41974 41974 $as_echo "no" >&6; }
41975 41975 fi
41976 41976
41977 41977
41978 41978 test -n "$NM" && break
41979 41979 done
41980 41980 fi
41981 41981 if test -z "$NM"; then
41982 41982 ac_ct_NM=$NM
41983 41983 for ac_prog in nm
41984 41984 do
41985 41985 # Extract the first word of "$ac_prog", so it can be a program name with args.
41986 41986 set dummy $ac_prog; ac_word=$2
41987 41987 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
41988 41988 $as_echo_n "checking for $ac_word... " >&6; }
41989 41989 if ${ac_cv_prog_ac_ct_NM+:} false; then :
41990 41990 $as_echo_n "(cached) " >&6
41991 41991 else
41992 41992 if test -n "$ac_ct_NM"; then
41993 41993 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
41994 41994 else
41995 41995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
41996 41996 for as_dir in $PATH
41997 41997 do
41998 41998 IFS=$as_save_IFS
41999 41999 test -z "$as_dir" && as_dir=.
42000 42000 for ac_exec_ext in '' $ac_executable_extensions; do
42001 42001 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42002 42002 ac_cv_prog_ac_ct_NM="$ac_prog"
42003 42003 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42004 42004 break 2
42005 42005 fi
42006 42006 done
42007 42007 done
42008 42008 IFS=$as_save_IFS
42009 42009
42010 42010 fi
42011 42011 fi
42012 42012 ac_ct_NM=$ac_cv_prog_ac_ct_NM
42013 42013 if test -n "$ac_ct_NM"; then
42014 42014 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
42015 42015 $as_echo "$ac_ct_NM" >&6; }
42016 42016 else
42017 42017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42018 42018 $as_echo "no" >&6; }
42019 42019 fi
42020 42020
42021 42021
42022 42022 test -n "$ac_ct_NM" && break
42023 42023 done
42024 42024
42025 42025 if test "x$ac_ct_NM" = x; then
42026 42026 NM=""
42027 42027 else
42028 42028 case $cross_compiling:$ac_tool_warned in
42029 42029 yes:)
42030 42030 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
42031 42031 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
42032 42032 ac_tool_warned=yes ;;
42033 42033 esac
42034 42034 NM=$ac_ct_NM
42035 42035 fi
42036 42036 fi
42037 42037
42038 42038 else
42039 42039 # The variable is set, but is it from the command line or the environment?
42040 42040
42041 42041 # Try to remove the string !NM! from our list.
42042 42042 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
42043 42043 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
42044 42044 # If it failed, the variable was not from the command line. Ignore it,
42045 42045 # but warn the user (except for BASH, which is always set by the calling BASH).
42046 42046 if test "xNM" != xBASH; then
42047 42047 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
42048 42048 $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
42049 42049 fi
42050 42050 # Try to locate tool using the code snippet
42051 42051 if test -n "$ac_tool_prefix"; then
42052 42052 for ac_prog in nm
42053 42053 do
42054 42054 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
42055 42055 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
42056 42056 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42057 42057 $as_echo_n "checking for $ac_word... " >&6; }
42058 42058 if ${ac_cv_prog_NM+:} false; then :
42059 42059 $as_echo_n "(cached) " >&6
42060 42060 else
42061 42061 if test -n "$NM"; then
42062 42062 ac_cv_prog_NM="$NM" # Let the user override the test.
42063 42063 else
42064 42064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42065 42065 for as_dir in $PATH
42066 42066 do
42067 42067 IFS=$as_save_IFS
42068 42068 test -z "$as_dir" && as_dir=.
42069 42069 for ac_exec_ext in '' $ac_executable_extensions; do
42070 42070 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42071 42071 ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
42072 42072 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42073 42073 break 2
42074 42074 fi
42075 42075 done
42076 42076 done
42077 42077 IFS=$as_save_IFS
42078 42078
42079 42079 fi
42080 42080 fi
42081 42081 NM=$ac_cv_prog_NM
42082 42082 if test -n "$NM"; then
42083 42083 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
42084 42084 $as_echo "$NM" >&6; }
42085 42085 else
42086 42086 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42087 42087 $as_echo "no" >&6; }
42088 42088 fi
42089 42089
42090 42090
42091 42091 test -n "$NM" && break
42092 42092 done
42093 42093 fi
42094 42094 if test -z "$NM"; then
42095 42095 ac_ct_NM=$NM
42096 42096 for ac_prog in nm
42097 42097 do
42098 42098 # Extract the first word of "$ac_prog", so it can be a program name with args.
42099 42099 set dummy $ac_prog; ac_word=$2
42100 42100 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42101 42101 $as_echo_n "checking for $ac_word... " >&6; }
42102 42102 if ${ac_cv_prog_ac_ct_NM+:} false; then :
42103 42103 $as_echo_n "(cached) " >&6
42104 42104 else
42105 42105 if test -n "$ac_ct_NM"; then
42106 42106 ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
42107 42107 else
42108 42108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42109 42109 for as_dir in $PATH
42110 42110 do
42111 42111 IFS=$as_save_IFS
42112 42112 test -z "$as_dir" && as_dir=.
42113 42113 for ac_exec_ext in '' $ac_executable_extensions; do
42114 42114 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42115 42115 ac_cv_prog_ac_ct_NM="$ac_prog"
42116 42116 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42117 42117 break 2
42118 42118 fi
42119 42119 done
42120 42120 done
42121 42121 IFS=$as_save_IFS
42122 42122
42123 42123 fi
42124 42124 fi
42125 42125 ac_ct_NM=$ac_cv_prog_ac_ct_NM
42126 42126 if test -n "$ac_ct_NM"; then
42127 42127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
42128 42128 $as_echo "$ac_ct_NM" >&6; }
42129 42129 else
42130 42130 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42131 42131 $as_echo "no" >&6; }
42132 42132 fi
42133 42133
42134 42134
42135 42135 test -n "$ac_ct_NM" && break
42136 42136 done
42137 42137
42138 42138 if test "x$ac_ct_NM" = x; then
42139 42139 NM=""
42140 42140 else
42141 42141 case $cross_compiling:$ac_tool_warned in
42142 42142 yes:)
42143 42143 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
42144 42144 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
42145 42145 ac_tool_warned=yes ;;
42146 42146 esac
42147 42147 NM=$ac_ct_NM
42148 42148 fi
42149 42149 fi
42150 42150
42151 42151 else
42152 42152 # If it succeeded, then it was overridden by the user. We will use it
42153 42153 # for the tool.
42154 42154
42155 42155 # First remove it from the list of overridden variables, so we can test
42156 42156 # for unknown variables in the end.
42157 42157 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
42158 42158
42159 42159 # Check if we try to supply an empty value
42160 42160 if test "x$NM" = x; then
42161 42161 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
42162 42162 $as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
42163 42163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
42164 42164 $as_echo_n "checking for NM... " >&6; }
42165 42165 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
42166 42166 $as_echo "disabled" >&6; }
42167 42167 else
42168 42168 # Check if the provided tool contains a complete path.
42169 42169 tool_specified="$NM"
42170 42170 tool_basename="${tool_specified##*/}"
42171 42171 if test "x$tool_basename" = "x$tool_specified"; then
42172 42172 # A command without a complete path is provided, search $PATH.
42173 42173 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
42174 42174 $as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
42175 42175 # Extract the first word of "$tool_basename", so it can be a program name with args.
42176 42176 set dummy $tool_basename; ac_word=$2
42177 42177 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42178 42178 $as_echo_n "checking for $ac_word... " >&6; }
42179 42179 if ${ac_cv_path_NM+:} false; then :
42180 42180 $as_echo_n "(cached) " >&6
42181 42181 else
42182 42182 case $NM in
42183 42183 [\\/]* | ?:[\\/]*)
42184 42184 ac_cv_path_NM="$NM" # Let the user override the test with a path.
42185 42185 ;;
42186 42186 *)
42187 42187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42188 42188 for as_dir in $PATH
42189 42189 do
42190 42190 IFS=$as_save_IFS
42191 42191 test -z "$as_dir" && as_dir=.
42192 42192 for ac_exec_ext in '' $ac_executable_extensions; do
42193 42193 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42194 42194 ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
42195 42195 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42196 42196 break 2
42197 42197 fi
42198 42198 done
42199 42199 done
42200 42200 IFS=$as_save_IFS
42201 42201
42202 42202 ;;
42203 42203 esac
42204 42204 fi
42205 42205 NM=$ac_cv_path_NM
42206 42206 if test -n "$NM"; then
42207 42207 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
42208 42208 $as_echo "$NM" >&6; }
42209 42209 else
42210 42210 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42211 42211 $as_echo "no" >&6; }
42212 42212 fi
42213 42213
42214 42214
42215 42215 if test "x$NM" = x; then
42216 42216 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
42217 42217 fi
42218 42218 else
42219 42219 # Otherwise we believe it is a complete path. Use it as it is.
42220 42220 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
42221 42221 $as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
42222 42222 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
42223 42223 $as_echo_n "checking for NM... " >&6; }
42224 42224 if test ! -x "$tool_specified"; then
42225 42225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
42226 42226 $as_echo "not found" >&6; }
42227 42227 as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
42228 42228 fi
42229 42229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
42230 42230 $as_echo "$tool_specified" >&6; }
42231 42231 fi
42232 42232 fi
42233 42233 fi
42234 42234
42235 42235 fi
42236 42236
42237 42237
42238 42238 fi
42239 42239
42240 42240 # Only process if variable expands to non-empty
42241 42241
42242 42242 if test "x$NM" != x; then
42243 42243 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42244 42244
42245 42245 # First separate the path from the arguments. This will split at the first
42246 42246 # space.
42247 42247 complete="$NM"
42248 42248 path="${complete%% *}"
42249 42249 tmp="$complete EOL"
42250 42250 arguments="${tmp#* }"
42251 42251
42252 42252 # Input might be given as Windows format, start by converting to
42253 42253 # unix format.
42254 42254 new_path=`$CYGPATH -u "$path"`
42255 42255
42256 42256 # Now try to locate executable using which
42257 42257 new_path=`$WHICH "$new_path" 2> /dev/null`
42258 42258 # bat and cmd files are not always considered executable in cygwin causing which
42259 42259 # to not find them
42260 42260 if test "x$new_path" = x \
42261 42261 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
42262 42262 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
42263 42263 new_path=`$CYGPATH -u "$path"`
42264 42264 fi
42265 42265 if test "x$new_path" = x; then
42266 42266 # Oops. Which didn't find the executable.
42267 42267 # The splitting of arguments from the executable at a space might have been incorrect,
42268 42268 # since paths with space are more likely in Windows. Give it another try with the whole
42269 42269 # argument.
42270 42270 path="$complete"
42271 42271 arguments="EOL"
42272 42272 new_path=`$CYGPATH -u "$path"`
42273 42273 new_path=`$WHICH "$new_path" 2> /dev/null`
42274 42274 # bat and cmd files are not always considered executable in cygwin causing which
42275 42275 # to not find them
42276 42276 if test "x$new_path" = x \
42277 42277 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
42278 42278 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
42279 42279 new_path=`$CYGPATH -u "$path"`
42280 42280 fi
42281 42281 if test "x$new_path" = x; then
42282 42282 # It's still not found. Now this is an unrecoverable error.
42283 42283 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
42284 42284 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
42285 42285 has_space=`$ECHO "$complete" | $GREP " "`
42286 42286 if test "x$has_space" != x; then
42287 42287 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
42288 42288 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
42289 42289 fi
42290 42290 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
42291 42291 fi
42292 42292 fi
42293 42293
42294 42294 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
42295 42295 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
42296 42296 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
42297 42297 # "foo.exe" is OK but "foo" is an error.
42298 42298 #
42299 42299 # This test is therefore slightly more accurate than "test -f" to check for file presence.
42300 42300 # It is also a way to make sure we got the proper file name for the real test later on.
42301 42301 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
42302 42302 if test "x$test_shortpath" = x; then
42303 42303 # Short path failed, file does not exist as specified.
42304 42304 # Try adding .exe or .cmd
42305 42305 if test -f "${new_path}.exe"; then
42306 42306 input_to_shortpath="${new_path}.exe"
42307 42307 elif test -f "${new_path}.cmd"; then
42308 42308 input_to_shortpath="${new_path}.cmd"
42309 42309 else
42310 42310 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
42311 42311 $as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
42312 42312 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
42313 42313 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
42314 42314 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
42315 42315 fi
42316 42316 else
42317 42317 input_to_shortpath="$new_path"
42318 42318 fi
42319 42319
42320 42320 # Call helper function which possibly converts this using DOS-style short mode.
42321 42321 # If so, the updated path is stored in $new_path.
42322 42322 new_path="$input_to_shortpath"
42323 42323
42324 42324 input_path="$input_to_shortpath"
42325 42325 # Check if we need to convert this using DOS-style short mode. If the path
42326 42326 # contains just simple characters, use it. Otherwise (spaces, weird characters),
42327 42327 # take no chances and rewrite it.
42328 42328 # Note: m4 eats our [], so we need to use [ and ] instead.
42329 42329 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
42330 42330 if test "x$has_forbidden_chars" != x; then
42331 42331 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
42332 42332 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
42333 42333 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
42334 42334 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
42335 42335 # Going to short mode and back again did indeed matter. Since short mode is
42336 42336 # case insensitive, let's make it lowercase to improve readability.
42337 42337 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
42338 42338 # Now convert it back to Unix-style (cygpath)
42339 42339 input_path=`$CYGPATH -u "$shortmode_path"`
42340 42340 new_path="$input_path"
42341 42341 fi
42342 42342 fi
42343 42343
42344 42344 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
42345 42345 if test "x$test_cygdrive_prefix" = x; then
42346 42346 # As a simple fix, exclude /usr/bin since it's not a real path.
42347 42347 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
42348 42348 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
42349 42349 # a path prefixed by /cygdrive for fixpath to work.
42350 42350 new_path="$CYGWIN_ROOT_PATH$input_path"
42351 42351 fi
42352 42352 fi
42353 42353
42354 42354 # remove trailing .exe if any
42355 42355 new_path="${new_path/%.exe/}"
42356 42356
42357 42357 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42358 42358
42359 42359 # First separate the path from the arguments. This will split at the first
42360 42360 # space.
42361 42361 complete="$NM"
42362 42362 path="${complete%% *}"
42363 42363 tmp="$complete EOL"
42364 42364 arguments="${tmp#* }"
42365 42365
42366 42366 # Input might be given as Windows format, start by converting to
42367 42367 # unix format.
42368 42368 new_path="$path"
42369 42369
42370 42370 windows_path="$new_path"
42371 42371 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42372 42372 unix_path=`$CYGPATH -u "$windows_path"`
42373 42373 new_path="$unix_path"
42374 42374 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42375 42375 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
42376 42376 new_path="$unix_path"
42377 42377 fi
42378 42378
42379 42379
42380 42380 # Now try to locate executable using which
42381 42381 new_path=`$WHICH "$new_path" 2> /dev/null`
42382 42382
42383 42383 if test "x$new_path" = x; then
42384 42384 # Oops. Which didn't find the executable.
42385 42385 # The splitting of arguments from the executable at a space might have been incorrect,
42386 42386 # since paths with space are more likely in Windows. Give it another try with the whole
42387 42387 # argument.
42388 42388 path="$complete"
42389 42389 arguments="EOL"
42390 42390 new_path="$path"
42391 42391
42392 42392 windows_path="$new_path"
42393 42393 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42394 42394 unix_path=`$CYGPATH -u "$windows_path"`
42395 42395 new_path="$unix_path"
42396 42396 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42397 42397 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
42398 42398 new_path="$unix_path"
42399 42399 fi
42400 42400
42401 42401
42402 42402 new_path=`$WHICH "$new_path" 2> /dev/null`
42403 42403 # bat and cmd files are not always considered executable in MSYS causing which
42404 42404 # to not find them
42405 42405 if test "x$new_path" = x \
42406 42406 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
42407 42407 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
42408 42408 new_path="$path"
42409 42409
42410 42410 windows_path="$new_path"
42411 42411 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42412 42412 unix_path=`$CYGPATH -u "$windows_path"`
42413 42413 new_path="$unix_path"
42414 42414 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42415 42415 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
42416 42416 new_path="$unix_path"
42417 42417 fi
42418 42418
42419 42419 fi
42420 42420
42421 42421 if test "x$new_path" = x; then
42422 42422 # It's still not found. Now this is an unrecoverable error.
42423 42423 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
42424 42424 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
42425 42425 has_space=`$ECHO "$complete" | $GREP " "`
42426 42426 if test "x$has_space" != x; then
42427 42427 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
42428 42428 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
42429 42429 fi
42430 42430 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
42431 42431 fi
42432 42432 fi
42433 42433
42434 42434 # Now new_path has a complete unix path to the binary
42435 42435 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
42436 42436 # Keep paths in /bin as-is, but remove trailing .exe if any
42437 42437 new_path="${new_path/%.exe/}"
42438 42438 # Do not save /bin paths to all_fixpath_prefixes!
42439 42439 else
42440 42440 # Not in mixed or Windows style, start by that.
42441 42441 new_path=`cmd //c echo $new_path`
42442 42442
42443 42443 input_path="$new_path"
42444 42444 # Check if we need to convert this using DOS-style short mode. If the path
42445 42445 # contains just simple characters, use it. Otherwise (spaces, weird characters),
42446 42446 # take no chances and rewrite it.
42447 42447 # Note: m4 eats our [], so we need to use [ and ] instead.
42448 42448 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
42449 42449 if test "x$has_forbidden_chars" != x; then
42450 42450 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
42451 42451 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
42452 42452 fi
42453 42453
42454 42454 # Output is in $new_path
42455 42455
42456 42456 windows_path="$new_path"
42457 42457 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42458 42458 unix_path=`$CYGPATH -u "$windows_path"`
42459 42459 new_path="$unix_path"
42460 42460 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42461 42461 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
42462 42462 new_path="$unix_path"
42463 42463 fi
42464 42464
42465 42465 # remove trailing .exe if any
42466 42466 new_path="${new_path/%.exe/}"
42467 42467
42468 42468 # Save the first 10 bytes of this path to the storage, so fixpath can work.
42469 42469 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
42470 42470 fi
42471 42471
42472 42472 else
42473 42473 # We're on a unix platform. Hooray! :)
42474 42474 # First separate the path from the arguments. This will split at the first
42475 42475 # space.
42476 42476 complete="$NM"
42477 42477 path="${complete%% *}"
42478 42478 tmp="$complete EOL"
42479 42479 arguments="${tmp#* }"
42480 42480
42481 42481 # Cannot rely on the command "which" here since it doesn't always work.
42482 42482 is_absolute_path=`$ECHO "$path" | $GREP ^/`
42483 42483 if test -z "$is_absolute_path"; then
42484 42484 # Path to executable is not absolute. Find it.
42485 42485 IFS_save="$IFS"
42486 42486 IFS=:
42487 42487 for p in $PATH; do
42488 42488 if test -f "$p/$path" && test -x "$p/$path"; then
42489 42489 new_path="$p/$path"
42490 42490 break
42491 42491 fi
42492 42492 done
42493 42493 IFS="$IFS_save"
42494 42494 else
42495 42495 # This is an absolute path, we can use it without further modifications.
42496 42496 new_path="$path"
42497 42497 fi
42498 42498
42499 42499 if test "x$new_path" = x; then
42500 42500 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
42501 42501 $as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
42502 42502 has_space=`$ECHO "$complete" | $GREP " "`
42503 42503 if test "x$has_space" != x; then
42504 42504 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
42505 42505 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
42506 42506 fi
42507 42507 as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
42508 42508 fi
42509 42509 fi
42510 42510
42511 42511 # Now join together the path and the arguments once again
42512 42512 if test "x$arguments" != xEOL; then
42513 42513 new_complete="$new_path ${arguments% *}"
42514 42514 else
42515 42515 new_complete="$new_path"
42516 42516 fi
42517 42517
42518 42518 if test "x$complete" != "x$new_complete"; then
42519 42519 NM="$new_complete"
42520 42520 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
42521 42521 $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
42522 42522 fi
42523 42523 fi
42524 42524
42525 42525 GNM="$NM"
42526 42526
42527 42527 fi
42528 42528
42529 42529 # objcopy is used for moving debug symbols to separate files when
42530 42530 # full debug symbols are enabled.
42531 42531 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
42532 42532
42533 42533
42534 42534 # Publish this variable in the help.
42535 42535
42536 42536
42537 42537 if [ -z "${OBJCOPY+x}" ]; then
42538 42538 # The variable is not set by user, try to locate tool using the code snippet
42539 42539 if test -n "$ac_tool_prefix"; then
42540 42540 for ac_prog in gobjcopy objcopy
42541 42541 do
42542 42542 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
42543 42543 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
42544 42544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42545 42545 $as_echo_n "checking for $ac_word... " >&6; }
42546 42546 if ${ac_cv_prog_OBJCOPY+:} false; then :
42547 42547 $as_echo_n "(cached) " >&6
42548 42548 else
42549 42549 if test -n "$OBJCOPY"; then
42550 42550 ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
42551 42551 else
42552 42552 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42553 42553 for as_dir in $PATH
42554 42554 do
42555 42555 IFS=$as_save_IFS
42556 42556 test -z "$as_dir" && as_dir=.
42557 42557 for ac_exec_ext in '' $ac_executable_extensions; do
42558 42558 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42559 42559 ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
42560 42560 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42561 42561 break 2
42562 42562 fi
42563 42563 done
42564 42564 done
42565 42565 IFS=$as_save_IFS
42566 42566
42567 42567 fi
42568 42568 fi
42569 42569 OBJCOPY=$ac_cv_prog_OBJCOPY
42570 42570 if test -n "$OBJCOPY"; then
42571 42571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
42572 42572 $as_echo "$OBJCOPY" >&6; }
42573 42573 else
42574 42574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42575 42575 $as_echo "no" >&6; }
42576 42576 fi
42577 42577
42578 42578
42579 42579 test -n "$OBJCOPY" && break
42580 42580 done
42581 42581 fi
42582 42582 if test -z "$OBJCOPY"; then
42583 42583 ac_ct_OBJCOPY=$OBJCOPY
42584 42584 for ac_prog in gobjcopy objcopy
42585 42585 do
42586 42586 # Extract the first word of "$ac_prog", so it can be a program name with args.
42587 42587 set dummy $ac_prog; ac_word=$2
42588 42588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42589 42589 $as_echo_n "checking for $ac_word... " >&6; }
42590 42590 if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
42591 42591 $as_echo_n "(cached) " >&6
42592 42592 else
42593 42593 if test -n "$ac_ct_OBJCOPY"; then
42594 42594 ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
42595 42595 else
42596 42596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42597 42597 for as_dir in $PATH
42598 42598 do
42599 42599 IFS=$as_save_IFS
42600 42600 test -z "$as_dir" && as_dir=.
42601 42601 for ac_exec_ext in '' $ac_executable_extensions; do
42602 42602 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42603 42603 ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
42604 42604 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42605 42605 break 2
42606 42606 fi
42607 42607 done
42608 42608 done
42609 42609 IFS=$as_save_IFS
42610 42610
42611 42611 fi
42612 42612 fi
42613 42613 ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
42614 42614 if test -n "$ac_ct_OBJCOPY"; then
42615 42615 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
42616 42616 $as_echo "$ac_ct_OBJCOPY" >&6; }
42617 42617 else
42618 42618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42619 42619 $as_echo "no" >&6; }
42620 42620 fi
42621 42621
42622 42622
42623 42623 test -n "$ac_ct_OBJCOPY" && break
42624 42624 done
42625 42625
42626 42626 if test "x$ac_ct_OBJCOPY" = x; then
42627 42627 OBJCOPY=""
42628 42628 else
42629 42629 case $cross_compiling:$ac_tool_warned in
42630 42630 yes:)
42631 42631 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
42632 42632 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
42633 42633 ac_tool_warned=yes ;;
42634 42634 esac
42635 42635 OBJCOPY=$ac_ct_OBJCOPY
42636 42636 fi
42637 42637 fi
42638 42638
42639 42639 else
42640 42640 # The variable is set, but is it from the command line or the environment?
42641 42641
42642 42642 # Try to remove the string !OBJCOPY! from our list.
42643 42643 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJCOPY!/}
42644 42644 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
42645 42645 # If it failed, the variable was not from the command line. Ignore it,
42646 42646 # but warn the user (except for BASH, which is always set by the calling BASH).
42647 42647 if test "xOBJCOPY" != xBASH; then
42648 42648 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
42649 42649 $as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
42650 42650 fi
42651 42651 # Try to locate tool using the code snippet
42652 42652 if test -n "$ac_tool_prefix"; then
42653 42653 for ac_prog in gobjcopy objcopy
42654 42654 do
42655 42655 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
42656 42656 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
42657 42657 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42658 42658 $as_echo_n "checking for $ac_word... " >&6; }
42659 42659 if ${ac_cv_prog_OBJCOPY+:} false; then :
42660 42660 $as_echo_n "(cached) " >&6
42661 42661 else
42662 42662 if test -n "$OBJCOPY"; then
42663 42663 ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
42664 42664 else
42665 42665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42666 42666 for as_dir in $PATH
42667 42667 do
42668 42668 IFS=$as_save_IFS
42669 42669 test -z "$as_dir" && as_dir=.
42670 42670 for ac_exec_ext in '' $ac_executable_extensions; do
42671 42671 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42672 42672 ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
42673 42673 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42674 42674 break 2
42675 42675 fi
42676 42676 done
42677 42677 done
42678 42678 IFS=$as_save_IFS
42679 42679
42680 42680 fi
42681 42681 fi
42682 42682 OBJCOPY=$ac_cv_prog_OBJCOPY
42683 42683 if test -n "$OBJCOPY"; then
42684 42684 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
42685 42685 $as_echo "$OBJCOPY" >&6; }
42686 42686 else
42687 42687 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42688 42688 $as_echo "no" >&6; }
42689 42689 fi
42690 42690
42691 42691
42692 42692 test -n "$OBJCOPY" && break
42693 42693 done
42694 42694 fi
42695 42695 if test -z "$OBJCOPY"; then
42696 42696 ac_ct_OBJCOPY=$OBJCOPY
42697 42697 for ac_prog in gobjcopy objcopy
42698 42698 do
42699 42699 # Extract the first word of "$ac_prog", so it can be a program name with args.
42700 42700 set dummy $ac_prog; ac_word=$2
42701 42701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42702 42702 $as_echo_n "checking for $ac_word... " >&6; }
42703 42703 if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
42704 42704 $as_echo_n "(cached) " >&6
42705 42705 else
42706 42706 if test -n "$ac_ct_OBJCOPY"; then
42707 42707 ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
42708 42708 else
42709 42709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42710 42710 for as_dir in $PATH
42711 42711 do
42712 42712 IFS=$as_save_IFS
42713 42713 test -z "$as_dir" && as_dir=.
42714 42714 for ac_exec_ext in '' $ac_executable_extensions; do
42715 42715 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42716 42716 ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
42717 42717 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42718 42718 break 2
42719 42719 fi
42720 42720 done
42721 42721 done
42722 42722 IFS=$as_save_IFS
42723 42723
42724 42724 fi
42725 42725 fi
42726 42726 ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
42727 42727 if test -n "$ac_ct_OBJCOPY"; then
42728 42728 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
42729 42729 $as_echo "$ac_ct_OBJCOPY" >&6; }
42730 42730 else
42731 42731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42732 42732 $as_echo "no" >&6; }
42733 42733 fi
42734 42734
42735 42735
42736 42736 test -n "$ac_ct_OBJCOPY" && break
42737 42737 done
42738 42738
42739 42739 if test "x$ac_ct_OBJCOPY" = x; then
42740 42740 OBJCOPY=""
42741 42741 else
42742 42742 case $cross_compiling:$ac_tool_warned in
42743 42743 yes:)
42744 42744 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
42745 42745 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
42746 42746 ac_tool_warned=yes ;;
42747 42747 esac
42748 42748 OBJCOPY=$ac_ct_OBJCOPY
42749 42749 fi
42750 42750 fi
42751 42751
42752 42752 else
42753 42753 # If it succeeded, then it was overridden by the user. We will use it
42754 42754 # for the tool.
42755 42755
42756 42756 # First remove it from the list of overridden variables, so we can test
42757 42757 # for unknown variables in the end.
42758 42758 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
42759 42759
42760 42760 # Check if we try to supply an empty value
42761 42761 if test "x$OBJCOPY" = x; then
42762 42762 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OBJCOPY= (no value)" >&5
42763 42763 $as_echo "$as_me: Setting user supplied tool OBJCOPY= (no value)" >&6;}
42764 42764 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
42765 42765 $as_echo_n "checking for OBJCOPY... " >&6; }
42766 42766 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
42767 42767 $as_echo "disabled" >&6; }
42768 42768 else
42769 42769 # Check if the provided tool contains a complete path.
42770 42770 tool_specified="$OBJCOPY"
42771 42771 tool_basename="${tool_specified##*/}"
42772 42772 if test "x$tool_basename" = "x$tool_specified"; then
42773 42773 # A command without a complete path is provided, search $PATH.
42774 42774 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
42775 42775 $as_echo "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
42776 42776 # Extract the first word of "$tool_basename", so it can be a program name with args.
42777 42777 set dummy $tool_basename; ac_word=$2
42778 42778 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
42779 42779 $as_echo_n "checking for $ac_word... " >&6; }
42780 42780 if ${ac_cv_path_OBJCOPY+:} false; then :
42781 42781 $as_echo_n "(cached) " >&6
42782 42782 else
42783 42783 case $OBJCOPY in
42784 42784 [\\/]* | ?:[\\/]*)
42785 42785 ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path.
42786 42786 ;;
42787 42787 *)
42788 42788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
42789 42789 for as_dir in $PATH
42790 42790 do
42791 42791 IFS=$as_save_IFS
42792 42792 test -z "$as_dir" && as_dir=.
42793 42793 for ac_exec_ext in '' $ac_executable_extensions; do
42794 42794 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
42795 42795 ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
42796 42796 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
42797 42797 break 2
42798 42798 fi
42799 42799 done
42800 42800 done
42801 42801 IFS=$as_save_IFS
42802 42802
42803 42803 ;;
42804 42804 esac
42805 42805 fi
42806 42806 OBJCOPY=$ac_cv_path_OBJCOPY
42807 42807 if test -n "$OBJCOPY"; then
42808 42808 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
42809 42809 $as_echo "$OBJCOPY" >&6; }
42810 42810 else
42811 42811 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
42812 42812 $as_echo "no" >&6; }
42813 42813 fi
42814 42814
42815 42815
42816 42816 if test "x$OBJCOPY" = x; then
42817 42817 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
42818 42818 fi
42819 42819 else
42820 42820 # Otherwise we believe it is a complete path. Use it as it is.
42821 42821 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
42822 42822 $as_echo "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
42823 42823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
42824 42824 $as_echo_n "checking for OBJCOPY... " >&6; }
42825 42825 if test ! -x "$tool_specified"; then
42826 42826 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
42827 42827 $as_echo "not found" >&6; }
42828 42828 as_fn_error $? "User supplied tool OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
42829 42829 fi
42830 42830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
42831 42831 $as_echo "$tool_specified" >&6; }
42832 42832 fi
42833 42833 fi
42834 42834 fi
42835 42835
42836 42836 fi
42837 42837
42838 42838
42839 42839 # Only call fixup if objcopy was found.
42840 42840 if test -n "$OBJCOPY"; then
42841 42841
42842 42842 # Only process if variable expands to non-empty
42843 42843
42844 42844 if test "x$OBJCOPY" != x; then
42845 42845 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42846 42846
42847 42847 # First separate the path from the arguments. This will split at the first
42848 42848 # space.
42849 42849 complete="$OBJCOPY"
42850 42850 path="${complete%% *}"
42851 42851 tmp="$complete EOL"
42852 42852 arguments="${tmp#* }"
42853 42853
42854 42854 # Input might be given as Windows format, start by converting to
42855 42855 # unix format.
42856 42856 new_path=`$CYGPATH -u "$path"`
42857 42857
42858 42858 # Now try to locate executable using which
42859 42859 new_path=`$WHICH "$new_path" 2> /dev/null`
42860 42860 # bat and cmd files are not always considered executable in cygwin causing which
42861 42861 # to not find them
42862 42862 if test "x$new_path" = x \
42863 42863 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
42864 42864 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
42865 42865 new_path=`$CYGPATH -u "$path"`
42866 42866 fi
42867 42867 if test "x$new_path" = x; then
42868 42868 # Oops. Which didn't find the executable.
42869 42869 # The splitting of arguments from the executable at a space might have been incorrect,
42870 42870 # since paths with space are more likely in Windows. Give it another try with the whole
42871 42871 # argument.
42872 42872 path="$complete"
42873 42873 arguments="EOL"
42874 42874 new_path=`$CYGPATH -u "$path"`
42875 42875 new_path=`$WHICH "$new_path" 2> /dev/null`
42876 42876 # bat and cmd files are not always considered executable in cygwin causing which
42877 42877 # to not find them
42878 42878 if test "x$new_path" = x \
42879 42879 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
42880 42880 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
42881 42881 new_path=`$CYGPATH -u "$path"`
42882 42882 fi
42883 42883 if test "x$new_path" = x; then
42884 42884 # It's still not found. Now this is an unrecoverable error.
42885 42885 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
42886 42886 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
42887 42887 has_space=`$ECHO "$complete" | $GREP " "`
42888 42888 if test "x$has_space" != x; then
42889 42889 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
42890 42890 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
42891 42891 fi
42892 42892 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
42893 42893 fi
42894 42894 fi
42895 42895
42896 42896 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
42897 42897 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
42898 42898 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
42899 42899 # "foo.exe" is OK but "foo" is an error.
42900 42900 #
42901 42901 # This test is therefore slightly more accurate than "test -f" to check for file presence.
42902 42902 # It is also a way to make sure we got the proper file name for the real test later on.
42903 42903 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
42904 42904 if test "x$test_shortpath" = x; then
42905 42905 # Short path failed, file does not exist as specified.
42906 42906 # Try adding .exe or .cmd
42907 42907 if test -f "${new_path}.exe"; then
42908 42908 input_to_shortpath="${new_path}.exe"
42909 42909 elif test -f "${new_path}.cmd"; then
42910 42910 input_to_shortpath="${new_path}.cmd"
42911 42911 else
42912 42912 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
42913 42913 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
42914 42914 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
42915 42915 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
42916 42916 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
42917 42917 fi
42918 42918 else
42919 42919 input_to_shortpath="$new_path"
42920 42920 fi
42921 42921
42922 42922 # Call helper function which possibly converts this using DOS-style short mode.
42923 42923 # If so, the updated path is stored in $new_path.
42924 42924 new_path="$input_to_shortpath"
42925 42925
42926 42926 input_path="$input_to_shortpath"
42927 42927 # Check if we need to convert this using DOS-style short mode. If the path
42928 42928 # contains just simple characters, use it. Otherwise (spaces, weird characters),
42929 42929 # take no chances and rewrite it.
42930 42930 # Note: m4 eats our [], so we need to use [ and ] instead.
42931 42931 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
42932 42932 if test "x$has_forbidden_chars" != x; then
42933 42933 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
42934 42934 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
42935 42935 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
42936 42936 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
42937 42937 # Going to short mode and back again did indeed matter. Since short mode is
42938 42938 # case insensitive, let's make it lowercase to improve readability.
42939 42939 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
42940 42940 # Now convert it back to Unix-style (cygpath)
42941 42941 input_path=`$CYGPATH -u "$shortmode_path"`
42942 42942 new_path="$input_path"
42943 42943 fi
42944 42944 fi
42945 42945
42946 42946 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
42947 42947 if test "x$test_cygdrive_prefix" = x; then
42948 42948 # As a simple fix, exclude /usr/bin since it's not a real path.
42949 42949 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
42950 42950 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
42951 42951 # a path prefixed by /cygdrive for fixpath to work.
42952 42952 new_path="$CYGWIN_ROOT_PATH$input_path"
42953 42953 fi
42954 42954 fi
42955 42955
42956 42956 # remove trailing .exe if any
42957 42957 new_path="${new_path/%.exe/}"
42958 42958
42959 42959 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42960 42960
42961 42961 # First separate the path from the arguments. This will split at the first
42962 42962 # space.
42963 42963 complete="$OBJCOPY"
42964 42964 path="${complete%% *}"
42965 42965 tmp="$complete EOL"
42966 42966 arguments="${tmp#* }"
42967 42967
42968 42968 # Input might be given as Windows format, start by converting to
42969 42969 # unix format.
42970 42970 new_path="$path"
42971 42971
42972 42972 windows_path="$new_path"
42973 42973 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42974 42974 unix_path=`$CYGPATH -u "$windows_path"`
42975 42975 new_path="$unix_path"
42976 42976 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42977 42977 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
42978 42978 new_path="$unix_path"
42979 42979 fi
42980 42980
42981 42981
42982 42982 # Now try to locate executable using which
42983 42983 new_path=`$WHICH "$new_path" 2> /dev/null`
42984 42984
42985 42985 if test "x$new_path" = x; then
42986 42986 # Oops. Which didn't find the executable.
42987 42987 # The splitting of arguments from the executable at a space might have been incorrect,
42988 42988 # since paths with space are more likely in Windows. Give it another try with the whole
42989 42989 # argument.
42990 42990 path="$complete"
42991 42991 arguments="EOL"
42992 42992 new_path="$path"
42993 42993
42994 42994 windows_path="$new_path"
42995 42995 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
42996 42996 unix_path=`$CYGPATH -u "$windows_path"`
42997 42997 new_path="$unix_path"
42998 42998 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
42999 42999 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43000 43000 new_path="$unix_path"
43001 43001 fi
43002 43002
43003 43003
43004 43004 new_path=`$WHICH "$new_path" 2> /dev/null`
43005 43005 # bat and cmd files are not always considered executable in MSYS causing which
43006 43006 # to not find them
43007 43007 if test "x$new_path" = x \
43008 43008 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
43009 43009 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
43010 43010 new_path="$path"
43011 43011
43012 43012 windows_path="$new_path"
43013 43013 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43014 43014 unix_path=`$CYGPATH -u "$windows_path"`
43015 43015 new_path="$unix_path"
43016 43016 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43017 43017 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43018 43018 new_path="$unix_path"
43019 43019 fi
43020 43020
43021 43021 fi
43022 43022
43023 43023 if test "x$new_path" = x; then
43024 43024 # It's still not found. Now this is an unrecoverable error.
43025 43025 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
43026 43026 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
43027 43027 has_space=`$ECHO "$complete" | $GREP " "`
43028 43028 if test "x$has_space" != x; then
43029 43029 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
43030 43030 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
43031 43031 fi
43032 43032 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
43033 43033 fi
43034 43034 fi
43035 43035
43036 43036 # Now new_path has a complete unix path to the binary
43037 43037 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
43038 43038 # Keep paths in /bin as-is, but remove trailing .exe if any
43039 43039 new_path="${new_path/%.exe/}"
43040 43040 # Do not save /bin paths to all_fixpath_prefixes!
43041 43041 else
43042 43042 # Not in mixed or Windows style, start by that.
43043 43043 new_path=`cmd //c echo $new_path`
43044 43044
43045 43045 input_path="$new_path"
43046 43046 # Check if we need to convert this using DOS-style short mode. If the path
43047 43047 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43048 43048 # take no chances and rewrite it.
43049 43049 # Note: m4 eats our [], so we need to use [ and ] instead.
43050 43050 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
43051 43051 if test "x$has_forbidden_chars" != x; then
43052 43052 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43053 43053 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43054 43054 fi
43055 43055
43056 43056 # Output is in $new_path
43057 43057
43058 43058 windows_path="$new_path"
43059 43059 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43060 43060 unix_path=`$CYGPATH -u "$windows_path"`
43061 43061 new_path="$unix_path"
43062 43062 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43063 43063 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43064 43064 new_path="$unix_path"
43065 43065 fi
43066 43066
43067 43067 # remove trailing .exe if any
43068 43068 new_path="${new_path/%.exe/}"
43069 43069
43070 43070 # Save the first 10 bytes of this path to the storage, so fixpath can work.
43071 43071 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
43072 43072 fi
43073 43073
43074 43074 else
43075 43075 # We're on a unix platform. Hooray! :)
43076 43076 # First separate the path from the arguments. This will split at the first
43077 43077 # space.
43078 43078 complete="$OBJCOPY"
43079 43079 path="${complete%% *}"
43080 43080 tmp="$complete EOL"
43081 43081 arguments="${tmp#* }"
43082 43082
43083 43083 # Cannot rely on the command "which" here since it doesn't always work.
43084 43084 is_absolute_path=`$ECHO "$path" | $GREP ^/`
43085 43085 if test -z "$is_absolute_path"; then
43086 43086 # Path to executable is not absolute. Find it.
43087 43087 IFS_save="$IFS"
43088 43088 IFS=:
43089 43089 for p in $PATH; do
43090 43090 if test -f "$p/$path" && test -x "$p/$path"; then
43091 43091 new_path="$p/$path"
43092 43092 break
43093 43093 fi
43094 43094 done
43095 43095 IFS="$IFS_save"
43096 43096 else
43097 43097 # This is an absolute path, we can use it without further modifications.
43098 43098 new_path="$path"
43099 43099 fi
43100 43100
43101 43101 if test "x$new_path" = x; then
43102 43102 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
43103 43103 $as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
43104 43104 has_space=`$ECHO "$complete" | $GREP " "`
43105 43105 if test "x$has_space" != x; then
43106 43106 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
43107 43107 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
43108 43108 fi
43109 43109 as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
43110 43110 fi
43111 43111 fi
43112 43112
43113 43113 # Now join together the path and the arguments once again
43114 43114 if test "x$arguments" != xEOL; then
43115 43115 new_complete="$new_path ${arguments% *}"
43116 43116 else
43117 43117 new_complete="$new_path"
43118 43118 fi
43119 43119
43120 43120 if test "x$complete" != "x$new_complete"; then
43121 43121 OBJCOPY="$new_complete"
43122 43122 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
43123 43123 $as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
43124 43124 fi
43125 43125 fi
43126 43126
43127 43127 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
43128 43128 # objcopy prior to 2.21.1 on solaris is broken and is not usable.
43129 43129 # Rewrite objcopy version output to VALID_VERSION or BAD_VERSION.
43130 43130 # - version number is last blank separate word on first line
43131 43131 # - version number formats that have been seen:
43132 43132 # - <major>.<minor>
43133 43133 # - <major>.<minor>.<micro>
43134 43134 OBJCOPY_VERSION=`$OBJCOPY --version | $HEAD -n 1`
43135 43135 # The outer [ ] is to prevent m4 from eating the [] in the sed expression.
43136 43136 OBJCOPY_VERSION_CHECK=`$ECHO $OBJCOPY_VERSION | $SED -n \
43137 43137 -e 's/.* //' \
43138 43138 -e '/^[01]\./b bad' \
43139 43139 -e '/^2\./{' \
43140 43140 -e ' s/^2\.//' \
43141 43141 -e ' /^[0-9]$/b bad' \
43142 43142 -e ' /^[0-9]\./b bad' \
43143 43143 -e ' /^1[0-9]$/b bad' \
43144 43144 -e ' /^1[0-9]\./b bad' \
43145 43145 -e ' /^20\./b bad' \
43146 43146 -e ' /^21\.0$/b bad' \
43147 43147 -e ' /^21\.0\./b bad' \
43148 43148 -e '}' \
43149 43149 -e ':good' \
43150 43150 -e 's/.*/VALID_VERSION/p' \
43151 43151 -e 'q' \
43152 43152 -e ':bad' \
43153 43153 -e 's/.*/BAD_VERSION/p' \
43154 43154 -e 'q'`
43155 43155 if test "x$OBJCOPY_VERSION_CHECK" = xBAD_VERSION; then
43156 43156 OBJCOPY=
43157 43157 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring found objcopy since it is broken (prior to 2.21.1). No debug symbols will be generated." >&5
43158 43158 $as_echo "$as_me: WARNING: Ignoring found objcopy since it is broken (prior to 2.21.1). No debug symbols will be generated." >&2;}
43159 43159 { $as_echo "$as_me:${as_lineno-$LINENO}: objcopy reports version $OBJCOPY_VERSION" >&5
43160 43160 $as_echo "$as_me: objcopy reports version $OBJCOPY_VERSION" >&6;}
43161 43161 { $as_echo "$as_me:${as_lineno-$LINENO}: Note: patch 149063-01 or newer contains the correct Solaris 10 SPARC version" >&5
43162 43162 $as_echo "$as_me: Note: patch 149063-01 or newer contains the correct Solaris 10 SPARC version" >&6;}
43163 43163 { $as_echo "$as_me:${as_lineno-$LINENO}: Note: patch 149064-01 or newer contains the correct Solaris 10 X86 version" >&5
43164 43164 $as_echo "$as_me: Note: patch 149064-01 or newer contains the correct Solaris 10 X86 version" >&6;}
43165 43165 { $as_echo "$as_me:${as_lineno-$LINENO}: Note: Solaris 11 Update 1 contains the correct version" >&5
43166 43166 $as_echo "$as_me: Note: Solaris 11 Update 1 contains the correct version" >&6;}
43167 43167 fi
43168 43168 fi
43169 43169 fi
43170 43170 fi
43171 43171
43172 43172
43173 43173
43174 43174 # Publish this variable in the help.
43175 43175
43176 43176
43177 43177 if [ -z "${OBJDUMP+x}" ]; then
43178 43178 # The variable is not set by user, try to locate tool using the code snippet
43179 43179 if test -n "$ac_tool_prefix"; then
43180 43180 for ac_prog in gobjdump objdump
43181 43181 do
43182 43182 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
43183 43183 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
43184 43184 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
43185 43185 $as_echo_n "checking for $ac_word... " >&6; }
43186 43186 if ${ac_cv_prog_OBJDUMP+:} false; then :
43187 43187 $as_echo_n "(cached) " >&6
43188 43188 else
43189 43189 if test -n "$OBJDUMP"; then
43190 43190 ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
43191 43191 else
43192 43192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
43193 43193 for as_dir in $PATH
43194 43194 do
43195 43195 IFS=$as_save_IFS
43196 43196 test -z "$as_dir" && as_dir=.
43197 43197 for ac_exec_ext in '' $ac_executable_extensions; do
43198 43198 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
43199 43199 ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
43200 43200 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
43201 43201 break 2
43202 43202 fi
43203 43203 done
43204 43204 done
43205 43205 IFS=$as_save_IFS
43206 43206
43207 43207 fi
43208 43208 fi
43209 43209 OBJDUMP=$ac_cv_prog_OBJDUMP
43210 43210 if test -n "$OBJDUMP"; then
43211 43211 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
43212 43212 $as_echo "$OBJDUMP" >&6; }
43213 43213 else
43214 43214 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
43215 43215 $as_echo "no" >&6; }
43216 43216 fi
43217 43217
43218 43218
43219 43219 test -n "$OBJDUMP" && break
43220 43220 done
43221 43221 fi
43222 43222 if test -z "$OBJDUMP"; then
43223 43223 ac_ct_OBJDUMP=$OBJDUMP
43224 43224 for ac_prog in gobjdump objdump
43225 43225 do
43226 43226 # Extract the first word of "$ac_prog", so it can be a program name with args.
43227 43227 set dummy $ac_prog; ac_word=$2
43228 43228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
43229 43229 $as_echo_n "checking for $ac_word... " >&6; }
43230 43230 if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
43231 43231 $as_echo_n "(cached) " >&6
43232 43232 else
43233 43233 if test -n "$ac_ct_OBJDUMP"; then
43234 43234 ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
43235 43235 else
43236 43236 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
43237 43237 for as_dir in $PATH
43238 43238 do
43239 43239 IFS=$as_save_IFS
43240 43240 test -z "$as_dir" && as_dir=.
43241 43241 for ac_exec_ext in '' $ac_executable_extensions; do
43242 43242 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
43243 43243 ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
43244 43244 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
43245 43245 break 2
43246 43246 fi
43247 43247 done
43248 43248 done
43249 43249 IFS=$as_save_IFS
43250 43250
43251 43251 fi
43252 43252 fi
43253 43253 ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
43254 43254 if test -n "$ac_ct_OBJDUMP"; then
43255 43255 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
43256 43256 $as_echo "$ac_ct_OBJDUMP" >&6; }
43257 43257 else
43258 43258 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
43259 43259 $as_echo "no" >&6; }
43260 43260 fi
43261 43261
43262 43262
43263 43263 test -n "$ac_ct_OBJDUMP" && break
43264 43264 done
43265 43265
43266 43266 if test "x$ac_ct_OBJDUMP" = x; then
43267 43267 OBJDUMP=""
43268 43268 else
43269 43269 case $cross_compiling:$ac_tool_warned in
43270 43270 yes:)
43271 43271 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
43272 43272 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
43273 43273 ac_tool_warned=yes ;;
43274 43274 esac
43275 43275 OBJDUMP=$ac_ct_OBJDUMP
43276 43276 fi
43277 43277 fi
43278 43278
43279 43279 else
43280 43280 # The variable is set, but is it from the command line or the environment?
43281 43281
43282 43282 # Try to remove the string !OBJDUMP! from our list.
43283 43283 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJDUMP!/}
43284 43284 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
43285 43285 # If it failed, the variable was not from the command line. Ignore it,
43286 43286 # but warn the user (except for BASH, which is always set by the calling BASH).
43287 43287 if test "xOBJDUMP" != xBASH; then
43288 43288 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
43289 43289 $as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
43290 43290 fi
43291 43291 # Try to locate tool using the code snippet
43292 43292 if test -n "$ac_tool_prefix"; then
43293 43293 for ac_prog in gobjdump objdump
43294 43294 do
43295 43295 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
43296 43296 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
43297 43297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
43298 43298 $as_echo_n "checking for $ac_word... " >&6; }
43299 43299 if ${ac_cv_prog_OBJDUMP+:} false; then :
43300 43300 $as_echo_n "(cached) " >&6
43301 43301 else
43302 43302 if test -n "$OBJDUMP"; then
43303 43303 ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
43304 43304 else
43305 43305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
43306 43306 for as_dir in $PATH
43307 43307 do
43308 43308 IFS=$as_save_IFS
43309 43309 test -z "$as_dir" && as_dir=.
43310 43310 for ac_exec_ext in '' $ac_executable_extensions; do
43311 43311 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
43312 43312 ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
43313 43313 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
43314 43314 break 2
43315 43315 fi
43316 43316 done
43317 43317 done
43318 43318 IFS=$as_save_IFS
43319 43319
43320 43320 fi
43321 43321 fi
43322 43322 OBJDUMP=$ac_cv_prog_OBJDUMP
43323 43323 if test -n "$OBJDUMP"; then
43324 43324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
43325 43325 $as_echo "$OBJDUMP" >&6; }
43326 43326 else
43327 43327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
43328 43328 $as_echo "no" >&6; }
43329 43329 fi
43330 43330
43331 43331
43332 43332 test -n "$OBJDUMP" && break
43333 43333 done
43334 43334 fi
43335 43335 if test -z "$OBJDUMP"; then
43336 43336 ac_ct_OBJDUMP=$OBJDUMP
43337 43337 for ac_prog in gobjdump objdump
43338 43338 do
43339 43339 # Extract the first word of "$ac_prog", so it can be a program name with args.
43340 43340 set dummy $ac_prog; ac_word=$2
43341 43341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
43342 43342 $as_echo_n "checking for $ac_word... " >&6; }
43343 43343 if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
43344 43344 $as_echo_n "(cached) " >&6
43345 43345 else
43346 43346 if test -n "$ac_ct_OBJDUMP"; then
43347 43347 ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
43348 43348 else
43349 43349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
43350 43350 for as_dir in $PATH
43351 43351 do
43352 43352 IFS=$as_save_IFS
43353 43353 test -z "$as_dir" && as_dir=.
43354 43354 for ac_exec_ext in '' $ac_executable_extensions; do
43355 43355 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
43356 43356 ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
43357 43357 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
43358 43358 break 2
43359 43359 fi
43360 43360 done
43361 43361 done
43362 43362 IFS=$as_save_IFS
43363 43363
43364 43364 fi
43365 43365 fi
43366 43366 ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
43367 43367 if test -n "$ac_ct_OBJDUMP"; then
43368 43368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
43369 43369 $as_echo "$ac_ct_OBJDUMP" >&6; }
43370 43370 else
43371 43371 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
43372 43372 $as_echo "no" >&6; }
43373 43373 fi
43374 43374
43375 43375
43376 43376 test -n "$ac_ct_OBJDUMP" && break
43377 43377 done
43378 43378
43379 43379 if test "x$ac_ct_OBJDUMP" = x; then
43380 43380 OBJDUMP=""
43381 43381 else
43382 43382 case $cross_compiling:$ac_tool_warned in
43383 43383 yes:)
43384 43384 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
43385 43385 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
43386 43386 ac_tool_warned=yes ;;
43387 43387 esac
43388 43388 OBJDUMP=$ac_ct_OBJDUMP
43389 43389 fi
43390 43390 fi
43391 43391
43392 43392 else
43393 43393 # If it succeeded, then it was overridden by the user. We will use it
43394 43394 # for the tool.
43395 43395
43396 43396 # First remove it from the list of overridden variables, so we can test
43397 43397 # for unknown variables in the end.
43398 43398 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
43399 43399
43400 43400 # Check if we try to supply an empty value
43401 43401 if test "x$OBJDUMP" = x; then
43402 43402 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OBJDUMP= (no value)" >&5
43403 43403 $as_echo "$as_me: Setting user supplied tool OBJDUMP= (no value)" >&6;}
43404 43404 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
43405 43405 $as_echo_n "checking for OBJDUMP... " >&6; }
43406 43406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
43407 43407 $as_echo "disabled" >&6; }
43408 43408 else
43409 43409 # Check if the provided tool contains a complete path.
43410 43410 tool_specified="$OBJDUMP"
43411 43411 tool_basename="${tool_specified##*/}"
43412 43412 if test "x$tool_basename" = "x$tool_specified"; then
43413 43413 # A command without a complete path is provided, search $PATH.
43414 43414 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
43415 43415 $as_echo "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
43416 43416 # Extract the first word of "$tool_basename", so it can be a program name with args.
43417 43417 set dummy $tool_basename; ac_word=$2
43418 43418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
43419 43419 $as_echo_n "checking for $ac_word... " >&6; }
43420 43420 if ${ac_cv_path_OBJDUMP+:} false; then :
43421 43421 $as_echo_n "(cached) " >&6
43422 43422 else
43423 43423 case $OBJDUMP in
43424 43424 [\\/]* | ?:[\\/]*)
43425 43425 ac_cv_path_OBJDUMP="$OBJDUMP" # Let the user override the test with a path.
43426 43426 ;;
43427 43427 *)
43428 43428 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
43429 43429 for as_dir in $PATH
43430 43430 do
43431 43431 IFS=$as_save_IFS
43432 43432 test -z "$as_dir" && as_dir=.
43433 43433 for ac_exec_ext in '' $ac_executable_extensions; do
43434 43434 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
43435 43435 ac_cv_path_OBJDUMP="$as_dir/$ac_word$ac_exec_ext"
43436 43436 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
43437 43437 break 2
43438 43438 fi
43439 43439 done
43440 43440 done
43441 43441 IFS=$as_save_IFS
43442 43442
43443 43443 ;;
43444 43444 esac
43445 43445 fi
43446 43446 OBJDUMP=$ac_cv_path_OBJDUMP
43447 43447 if test -n "$OBJDUMP"; then
43448 43448 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
43449 43449 $as_echo "$OBJDUMP" >&6; }
43450 43450 else
43451 43451 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
43452 43452 $as_echo "no" >&6; }
43453 43453 fi
43454 43454
43455 43455
43456 43456 if test "x$OBJDUMP" = x; then
43457 43457 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
43458 43458 fi
43459 43459 else
43460 43460 # Otherwise we believe it is a complete path. Use it as it is.
43461 43461 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
43462 43462 $as_echo "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
43463 43463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
43464 43464 $as_echo_n "checking for OBJDUMP... " >&6; }
43465 43465 if test ! -x "$tool_specified"; then
43466 43466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
43467 43467 $as_echo "not found" >&6; }
43468 43468 as_fn_error $? "User supplied tool OBJDUMP=$tool_specified does not exist or is not executable" "$LINENO" 5
43469 43469 fi
43470 43470 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
43471 43471 $as_echo "$tool_specified" >&6; }
43472 43472 fi
43473 43473 fi
43474 43474 fi
43475 43475
43476 43476 fi
43477 43477
43478 43478
43479 43479 if test "x$OBJDUMP" != x; then
43480 43480 # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE
43481 43481 # bails if argument is missing.
43482 43482
43483 43483 # Only process if variable expands to non-empty
43484 43484
43485 43485 if test "x$OBJDUMP" != x; then
43486 43486 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43487 43487
43488 43488 # First separate the path from the arguments. This will split at the first
43489 43489 # space.
43490 43490 complete="$OBJDUMP"
43491 43491 path="${complete%% *}"
43492 43492 tmp="$complete EOL"
43493 43493 arguments="${tmp#* }"
43494 43494
43495 43495 # Input might be given as Windows format, start by converting to
43496 43496 # unix format.
43497 43497 new_path=`$CYGPATH -u "$path"`
43498 43498
43499 43499 # Now try to locate executable using which
43500 43500 new_path=`$WHICH "$new_path" 2> /dev/null`
43501 43501 # bat and cmd files are not always considered executable in cygwin causing which
43502 43502 # to not find them
43503 43503 if test "x$new_path" = x \
43504 43504 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
43505 43505 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
43506 43506 new_path=`$CYGPATH -u "$path"`
43507 43507 fi
43508 43508 if test "x$new_path" = x; then
43509 43509 # Oops. Which didn't find the executable.
43510 43510 # The splitting of arguments from the executable at a space might have been incorrect,
43511 43511 # since paths with space are more likely in Windows. Give it another try with the whole
43512 43512 # argument.
43513 43513 path="$complete"
43514 43514 arguments="EOL"
43515 43515 new_path=`$CYGPATH -u "$path"`
43516 43516 new_path=`$WHICH "$new_path" 2> /dev/null`
43517 43517 # bat and cmd files are not always considered executable in cygwin causing which
43518 43518 # to not find them
43519 43519 if test "x$new_path" = x \
43520 43520 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
43521 43521 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
43522 43522 new_path=`$CYGPATH -u "$path"`
43523 43523 fi
43524 43524 if test "x$new_path" = x; then
43525 43525 # It's still not found. Now this is an unrecoverable error.
43526 43526 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
43527 43527 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
43528 43528 has_space=`$ECHO "$complete" | $GREP " "`
43529 43529 if test "x$has_space" != x; then
43530 43530 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
43531 43531 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
43532 43532 fi
43533 43533 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
43534 43534 fi
43535 43535 fi
43536 43536
43537 43537 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
43538 43538 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
43539 43539 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
43540 43540 # "foo.exe" is OK but "foo" is an error.
43541 43541 #
43542 43542 # This test is therefore slightly more accurate than "test -f" to check for file presence.
43543 43543 # It is also a way to make sure we got the proper file name for the real test later on.
43544 43544 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
43545 43545 if test "x$test_shortpath" = x; then
43546 43546 # Short path failed, file does not exist as specified.
43547 43547 # Try adding .exe or .cmd
43548 43548 if test -f "${new_path}.exe"; then
43549 43549 input_to_shortpath="${new_path}.exe"
43550 43550 elif test -f "${new_path}.cmd"; then
43551 43551 input_to_shortpath="${new_path}.cmd"
43552 43552 else
43553 43553 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
43554 43554 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
43555 43555 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
43556 43556 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
43557 43557 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
43558 43558 fi
43559 43559 else
43560 43560 input_to_shortpath="$new_path"
43561 43561 fi
43562 43562
43563 43563 # Call helper function which possibly converts this using DOS-style short mode.
43564 43564 # If so, the updated path is stored in $new_path.
43565 43565 new_path="$input_to_shortpath"
43566 43566
43567 43567 input_path="$input_to_shortpath"
43568 43568 # Check if we need to convert this using DOS-style short mode. If the path
43569 43569 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43570 43570 # take no chances and rewrite it.
43571 43571 # Note: m4 eats our [], so we need to use [ and ] instead.
43572 43572 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43573 43573 if test "x$has_forbidden_chars" != x; then
43574 43574 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43575 43575 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43576 43576 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43577 43577 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43578 43578 # Going to short mode and back again did indeed matter. Since short mode is
43579 43579 # case insensitive, let's make it lowercase to improve readability.
43580 43580 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43581 43581 # Now convert it back to Unix-style (cygpath)
43582 43582 input_path=`$CYGPATH -u "$shortmode_path"`
43583 43583 new_path="$input_path"
43584 43584 fi
43585 43585 fi
43586 43586
43587 43587 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43588 43588 if test "x$test_cygdrive_prefix" = x; then
43589 43589 # As a simple fix, exclude /usr/bin since it's not a real path.
43590 43590 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
43591 43591 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43592 43592 # a path prefixed by /cygdrive for fixpath to work.
43593 43593 new_path="$CYGWIN_ROOT_PATH$input_path"
43594 43594 fi
43595 43595 fi
43596 43596
43597 43597 # remove trailing .exe if any
43598 43598 new_path="${new_path/%.exe/}"
43599 43599
43600 43600 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43601 43601
43602 43602 # First separate the path from the arguments. This will split at the first
43603 43603 # space.
43604 43604 complete="$OBJDUMP"
43605 43605 path="${complete%% *}"
43606 43606 tmp="$complete EOL"
43607 43607 arguments="${tmp#* }"
43608 43608
43609 43609 # Input might be given as Windows format, start by converting to
43610 43610 # unix format.
43611 43611 new_path="$path"
43612 43612
43613 43613 windows_path="$new_path"
43614 43614 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43615 43615 unix_path=`$CYGPATH -u "$windows_path"`
43616 43616 new_path="$unix_path"
43617 43617 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43618 43618 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43619 43619 new_path="$unix_path"
43620 43620 fi
43621 43621
43622 43622
43623 43623 # Now try to locate executable using which
43624 43624 new_path=`$WHICH "$new_path" 2> /dev/null`
43625 43625
43626 43626 if test "x$new_path" = x; then
43627 43627 # Oops. Which didn't find the executable.
43628 43628 # The splitting of arguments from the executable at a space might have been incorrect,
43629 43629 # since paths with space are more likely in Windows. Give it another try with the whole
43630 43630 # argument.
43631 43631 path="$complete"
43632 43632 arguments="EOL"
43633 43633 new_path="$path"
43634 43634
43635 43635 windows_path="$new_path"
43636 43636 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43637 43637 unix_path=`$CYGPATH -u "$windows_path"`
43638 43638 new_path="$unix_path"
43639 43639 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43640 43640 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43641 43641 new_path="$unix_path"
43642 43642 fi
43643 43643
43644 43644
43645 43645 new_path=`$WHICH "$new_path" 2> /dev/null`
43646 43646 # bat and cmd files are not always considered executable in MSYS causing which
43647 43647 # to not find them
43648 43648 if test "x$new_path" = x \
43649 43649 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
43650 43650 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
43651 43651 new_path="$path"
43652 43652
43653 43653 windows_path="$new_path"
43654 43654 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43655 43655 unix_path=`$CYGPATH -u "$windows_path"`
43656 43656 new_path="$unix_path"
43657 43657 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43658 43658 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43659 43659 new_path="$unix_path"
43660 43660 fi
43661 43661
43662 43662 fi
43663 43663
43664 43664 if test "x$new_path" = x; then
43665 43665 # It's still not found. Now this is an unrecoverable error.
43666 43666 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
43667 43667 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
43668 43668 has_space=`$ECHO "$complete" | $GREP " "`
43669 43669 if test "x$has_space" != x; then
43670 43670 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
43671 43671 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
43672 43672 fi
43673 43673 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
43674 43674 fi
43675 43675 fi
43676 43676
43677 43677 # Now new_path has a complete unix path to the binary
43678 43678 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
43679 43679 # Keep paths in /bin as-is, but remove trailing .exe if any
43680 43680 new_path="${new_path/%.exe/}"
43681 43681 # Do not save /bin paths to all_fixpath_prefixes!
43682 43682 else
43683 43683 # Not in mixed or Windows style, start by that.
43684 43684 new_path=`cmd //c echo $new_path`
43685 43685
43686 43686 input_path="$new_path"
43687 43687 # Check if we need to convert this using DOS-style short mode. If the path
43688 43688 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43689 43689 # take no chances and rewrite it.
43690 43690 # Note: m4 eats our [], so we need to use [ and ] instead.
43691 43691 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
43692 43692 if test "x$has_forbidden_chars" != x; then
43693 43693 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43694 43694 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43695 43695 fi
43696 43696
43697 43697 # Output is in $new_path
43698 43698
43699 43699 windows_path="$new_path"
43700 43700 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43701 43701 unix_path=`$CYGPATH -u "$windows_path"`
43702 43702 new_path="$unix_path"
43703 43703 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43704 43704 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43705 43705 new_path="$unix_path"
43706 43706 fi
43707 43707
43708 43708 # remove trailing .exe if any
43709 43709 new_path="${new_path/%.exe/}"
43710 43710
43711 43711 # Save the first 10 bytes of this path to the storage, so fixpath can work.
43712 43712 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
43713 43713 fi
43714 43714
43715 43715 else
43716 43716 # We're on a unix platform. Hooray! :)
43717 43717 # First separate the path from the arguments. This will split at the first
43718 43718 # space.
43719 43719 complete="$OBJDUMP"
43720 43720 path="${complete%% *}"
43721 43721 tmp="$complete EOL"
43722 43722 arguments="${tmp#* }"
43723 43723
43724 43724 # Cannot rely on the command "which" here since it doesn't always work.
43725 43725 is_absolute_path=`$ECHO "$path" | $GREP ^/`
43726 43726 if test -z "$is_absolute_path"; then
43727 43727 # Path to executable is not absolute. Find it.
43728 43728 IFS_save="$IFS"
43729 43729 IFS=:
43730 43730 for p in $PATH; do
43731 43731 if test -f "$p/$path" && test -x "$p/$path"; then
43732 43732 new_path="$p/$path"
43733 43733 break
43734 43734 fi
43735 43735 done
43736 43736 IFS="$IFS_save"
43737 43737 else
43738 43738 # This is an absolute path, we can use it without further modifications.
43739 43739 new_path="$path"
43740 43740 fi
43741 43741
43742 43742 if test "x$new_path" = x; then
43743 43743 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
43744 43744 $as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
43745 43745 has_space=`$ECHO "$complete" | $GREP " "`
43746 43746 if test "x$has_space" != x; then
43747 43747 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
43748 43748 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
43749 43749 fi
43750 43750 as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
43751 43751 fi
43752 43752 fi
43753 43753
43754 43754 # Now join together the path and the arguments once again
43755 43755 if test "x$arguments" != xEOL; then
43756 43756 new_complete="$new_path ${arguments% *}"
43757 43757 else
43758 43758 new_complete="$new_path"
43759 43759 fi
43760 43760
43761 43761 if test "x$complete" != "x$new_complete"; then
43762 43762 OBJDUMP="$new_complete"
43763 43763 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
43764 43764 $as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
43765 43765 fi
43766 43766 fi
43767 43767
43768 43768 fi
43769 43769
43770 43770
43771 43771 # Restore old path, except for the microsoft toolchain, which requires VS_PATH
43772 43772 # to remain in place. Otherwise the compiler will not work in some siutations
43773 43773 # in later configure checks.
43774 43774 if test "x$TOOLCHAIN_TYPE" != "xmicrosoft"; then
43775 43775 PATH="$OLD_PATH"
43776 43776 fi
43777 43777
43778 43778 # Restore the flags to the user specified values.
43779 43779 # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
43780 43780 CFLAGS="$ORG_CFLAGS"
43781 43781 CXXFLAGS="$ORG_CXXFLAGS"
43782 43782
43783 43783
43784 43784 # Finally do some processing after the detection phase
43785 43785
43786 43786 if test "x$COMPILE_TYPE" = "xcross"; then
43787 43787 # Now we need to find a C/C++ compiler that can build executables for the
43788 43788 # build platform. We can't use the AC_PROG_CC macro, since it can only be
43789 43789 # used once. Also, we need to do this without adding a tools dir to the
43790 43790 # path, otherwise we might pick up cross-compilers which don't use standard
43791 43791 # naming.
43792 43792
43793 43793 OLDPATH="$PATH"
43794 43794
43795 43795
43796 43796 # Check whether --with-build-devkit was given.
43797 43797 if test "${with_build_devkit+set}" = set; then :
43798 43798 withval=$with_build_devkit;
43799 43799 fi
43800 43800
43801 43801 if test "x$with_build_devkit" = "xyes"; then
43802 43802 as_fn_error $? "--with-build-devkit must have a value" "$LINENO" 5
43803 43803 elif test -n "$with_build_devkit"; then
43804 43804 if test ! -d "$with_build_devkit"; then
43805 43805 as_fn_error $? "--with-build-devkit points to non existing dir: $with_build_devkit" "$LINENO" 5
43806 43806 else
43807 43807
43808 43808 # Only process if variable expands to non-empty
43809 43809
43810 43810 if test "x$with_build_devkit" != x; then
43811 43811 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43812 43812
43813 43813 # Input might be given as Windows format, start by converting to
43814 43814 # unix format.
43815 43815 path="$with_build_devkit"
43816 43816 new_path=`$CYGPATH -u "$path"`
43817 43817
43818 43818 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
43819 43819 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
43820 43820 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
43821 43821 # "foo.exe" is OK but "foo" is an error.
43822 43822 #
43823 43823 # This test is therefore slightly more accurate than "test -f" to check for file precense.
43824 43824 # It is also a way to make sure we got the proper file name for the real test later on.
43825 43825 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
43826 43826 if test "x$test_shortpath" = x; then
43827 43827 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&5
43828 43828 $as_echo "$as_me: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&6;}
43829 43829 as_fn_error $? "Cannot locate the the path of with_build_devkit" "$LINENO" 5
43830 43830 fi
43831 43831
43832 43832 # Call helper function which possibly converts this using DOS-style short mode.
43833 43833 # If so, the updated path is stored in $new_path.
43834 43834
43835 43835 input_path="$new_path"
43836 43836 # Check if we need to convert this using DOS-style short mode. If the path
43837 43837 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43838 43838 # take no chances and rewrite it.
43839 43839 # Note: m4 eats our [], so we need to use [ and ] instead.
43840 43840 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43841 43841 if test "x$has_forbidden_chars" != x; then
43842 43842 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43843 43843 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43844 43844 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43845 43845 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43846 43846 # Going to short mode and back again did indeed matter. Since short mode is
43847 43847 # case insensitive, let's make it lowercase to improve readability.
43848 43848 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43849 43849 # Now convert it back to Unix-style (cygpath)
43850 43850 input_path=`$CYGPATH -u "$shortmode_path"`
43851 43851 new_path="$input_path"
43852 43852 fi
43853 43853 fi
43854 43854
43855 43855 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43856 43856 if test "x$test_cygdrive_prefix" = x; then
43857 43857 # As a simple fix, exclude /usr/bin since it's not a real path.
43858 43858 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43859 43859 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43860 43860 # a path prefixed by /cygdrive for fixpath to work.
43861 43861 new_path="$CYGWIN_ROOT_PATH$input_path"
43862 43862 fi
43863 43863 fi
43864 43864
43865 43865
43866 43866 if test "x$path" != "x$new_path"; then
43867 43867 with_build_devkit="$new_path"
43868 43868 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_build_devkit to \"$new_path\"" >&5
43869 43869 $as_echo "$as_me: Rewriting with_build_devkit to \"$new_path\"" >&6;}
43870 43870 fi
43871 43871
43872 43872 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43873 43873
43874 43874 path="$with_build_devkit"
43875 43875 has_colon=`$ECHO $path | $GREP ^.:`
43876 43876 new_path="$path"
43877 43877 if test "x$has_colon" = x; then
43878 43878 # Not in mixed or Windows style, start by that.
43879 43879 new_path=`cmd //c echo $path`
43880 43880 fi
43881 43881
43882 43882
43883 43883 input_path="$new_path"
43884 43884 # Check if we need to convert this using DOS-style short mode. If the path
43885 43885 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43886 43886 # take no chances and rewrite it.
43887 43887 # Note: m4 eats our [], so we need to use [ and ] instead.
43888 43888 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
43889 43889 if test "x$has_forbidden_chars" != x; then
43890 43890 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43891 43891 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43892 43892 fi
43893 43893
43894 43894
43895 43895 windows_path="$new_path"
43896 43896 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
43897 43897 unix_path=`$CYGPATH -u "$windows_path"`
43898 43898 new_path="$unix_path"
43899 43899 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
43900 43900 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
43901 43901 new_path="$unix_path"
43902 43902 fi
43903 43903
43904 43904 if test "x$path" != "x$new_path"; then
43905 43905 with_build_devkit="$new_path"
43906 43906 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_build_devkit to \"$new_path\"" >&5
43907 43907 $as_echo "$as_me: Rewriting with_build_devkit to \"$new_path\"" >&6;}
43908 43908 fi
43909 43909
43910 43910 # Save the first 10 bytes of this path to the storage, so fixpath can work.
43911 43911 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
43912 43912
43913 43913 else
43914 43914 # We're on a unix platform. Hooray! :)
43915 43915 path="$with_build_devkit"
43916 43916 has_space=`$ECHO "$path" | $GREP " "`
43917 43917 if test "x$has_space" != x; then
43918 43918 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&5
43919 43919 $as_echo "$as_me: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&6;}
43920 43920 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
43921 43921 fi
43922 43922
43923 43923 # Use eval to expand a potential ~
43924 43924 eval path="$path"
43925 43925 if test ! -f "$path" && test ! -d "$path"; then
43926 43926 as_fn_error $? "The path of with_build_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
43927 43927 fi
43928 43928
43929 43929 if test -d "$path"; then
43930 43930 with_build_devkit="`cd "$path"; $THEPWDCMD -L`"
43931 43931 else
43932 43932 dir="`$DIRNAME "$path"`"
43933 43933 base="`$BASENAME "$path"`"
43934 43934 with_build_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
43935 43935 fi
43936 43936 fi
43937 43937 fi
43938 43938
43939 43939 BUILD_DEVKIT_ROOT="$with_build_devkit"
43940 43940 # Check for a meta data info file in the root of the devkit
43941 43941 if test -f "$BUILD_DEVKIT_ROOT/devkit.info"; then
43942 43942 # Process devkit.info so that existing devkit variables are not
43943 43943 # modified by this
43944 43944 $SED -e "s/^DEVKIT_/BUILD_DEVKIT_/g" \
43945 43945 -e "s/\$DEVKIT_ROOT/\$BUILD_DEVKIT_ROOT/g" \
43946 43946 -e "s/\$host/\$build/g" \
43947 43947 $BUILD_DEVKIT_ROOT/devkit.info \
43948 43948 > $CONFIGURESUPPORT_OUTPUTDIR/build-devkit.info
43949 43949 . $CONFIGURESUPPORT_OUTPUTDIR/build-devkit.info
43950 43950 # This potentially sets the following:
43951 43951 # A descriptive name of the devkit
43952 43952
43953 43953 if test "x$BUILD_DEVKIT_NAME" = x; then
43954 43954 eval BUILD_DEVKIT_NAME="\${BUILD_DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
43955 43955 fi
43956 43956
43957 43957 # Corresponds to --with-extra-path
43958 43958
43959 43959 if test "x$BUILD_DEVKIT_EXTRA_PATH" = x; then
43960 43960 eval BUILD_DEVKIT_EXTRA_PATH="\${BUILD_DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
43961 43961 fi
43962 43962
43963 43963 # Corresponds to --with-toolchain-path
43964 43964
43965 43965 if test "x$BUILD_DEVKIT_TOOLCHAIN_PATH" = x; then
43966 43966 eval BUILD_DEVKIT_TOOLCHAIN_PATH="\${BUILD_DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
43967 43967 fi
43968 43968
43969 43969 # Corresponds to --with-sysroot
43970 43970
43971 43971 if test "x$BUILD_DEVKIT_SYSROOT" = x; then
43972 43972 eval BUILD_DEVKIT_SYSROOT="\${BUILD_DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
43973 43973 fi
43974 43974
43975 43975 # Skip the Window specific parts
43976 43976 fi
43977 43977
43978 43978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for build platform devkit" >&5
43979 43979 $as_echo_n "checking for build platform devkit... " >&6; }
43980 43980 if test "x$BUILD_DEVKIT_NAME" != x; then
43981 43981 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_DEVKIT_NAME in $BUILD_DEVKIT_ROOT" >&5
43982 43982 $as_echo "$BUILD_DEVKIT_NAME in $BUILD_DEVKIT_ROOT" >&6; }
43983 43983 else
43984 43984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_DEVKIT_ROOT" >&5
43985 43985 $as_echo "$BUILD_DEVKIT_ROOT" >&6; }
43986 43986 fi
43987 43987
43988 43988 BUILD_SYSROOT="$BUILD_DEVKIT_SYSROOT"
43989 43989
43990 43990 if test "x$BUILD_SYSROOT" != "x"; then
43991 43991 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
43992 43992 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
43993 43993 # Solaris Studio does not have a concept of sysroot. Instead we must
43994 43994 # make sure the default include and lib dirs are appended to each
43995 43995 # compile and link command line. Must also add -I-xbuiltin to enable
43996 43996 # inlining of system functions and intrinsics.
43997 43997 BUILD_SYSROOT_CFLAGS="-I-xbuiltin -I$BUILD_SYSROOT/usr/include"
43998 43998 BUILD_SYSROOT_LDFLAGS="-L$BUILD_SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
43999 43999 -L$BUILD_SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR \
44000 44000 -L$BUILD_SYSROOT/usr/ccs/lib$OPENJDK_TARGET_CPU_ISADIR"
44001 44001 fi
44002 44002 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
44003 44003 BUILD_SYSROOT_CFLAGS="--sysroot=$BUILD_SYSROOT"
44004 44004 BUILD_SYSROOT_LDFLAGS="--sysroot=$BUILD_SYSROOT"
44005 44005 elif test "x$TOOLCHAIN_TYPE" = xclang; then
44006 44006 BUILD_SYSROOT_CFLAGS="-isysroot $BUILD_SYSROOT"
44007 44007 BUILD_SYSROOT_LDFLAGS="-isysroot $BUILD_SYSROOT"
44008 44008 fi
44009 44009 # Propagate the sysroot args to hotspot
44010 44010 BUILD_LEGACY_EXTRA_CFLAGS="$BUILD_LEGACY_EXTRA_CFLAGS $BUILD_SYSROOT_CFLAGS"
44011 44011 BUILD_LEGACY_EXTRA_CXXFLAGS="$BUILD_LEGACY_EXTRA_CXXFLAGS $BUILD_SYSROOT_CFLAGS"
44012 44012 BUILD_LEGACY_EXTRA_LDFLAGS="$BUILD_LEGACY_EXTRA_LDFLAGS $BUILD_SYSROOT_LDFLAGS"
44013 44013 # The global CFLAGS and LDFLAGS variables need these for configure to function
44014 44014 BUILD_CFLAGS="$BUILD_CFLAGS $BUILD_SYSROOT_CFLAGS"
44015 44015 BUILD_CPPFLAGS="$BUILD_CPPFLAGS $BUILD_SYSROOT_CFLAGS"
44016 44016 BUILD_CXXFLAGS="$BUILD_CXXFLAGS $BUILD_SYSROOT_CFLAGS"
44017 44017 BUILD_LDFLAGS="$BUILD_LDFLAGS $BUILD_SYSROOT_LDFLAGS"
44018 44018 fi
44019 44019
44020 44020 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
44021 44021 # We also need -iframework<path>/System/Library/Frameworks
44022 44022 BUILD_SYSROOT_CFLAGS="$BUILD_SYSROOT_CFLAGS -iframework $BUILD_SYSROOT/System/Library/Frameworks"
44023 44023 BUILD_SYSROOT_LDFLAGS="$BUILD_SYSROOT_LDFLAGS -iframework $BUILD_SYSROOT/System/Library/Frameworks"
44024 44024 # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
44025 44025 # set this here so it doesn't have to be peppered throughout the forest
44026 44026 BUILD_SYSROOT_CFLAGS="$BUILD_SYSROOT_CFLAGS -F $BUILD_SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
44027 44027 BUILD_SYSROOT_LDFLAGS="$BUILD_SYSROOT_LDFLAGS -F $BUILD_SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
44028 44028 fi
44029 44029
44030 44030
44031 44031
44032 44032
44033 44033
44034 44034 # Fallback default of just /bin if DEVKIT_PATH is not defined
44035 44035 if test "x$BUILD_DEVKIT_TOOLCHAIN_PATH" = x; then
44036 44036 BUILD_DEVKIT_TOOLCHAIN_PATH="$BUILD_DEVKIT_ROOT/bin"
44037 44037 fi
44038 44038 PATH="$BUILD_DEVKIT_TOOLCHAIN_PATH:$BUILD_DEVKIT_EXTRA_PATH"
44039 44039 fi
44040 44040 fi
44041 44041
44042 44042 # FIXME: we should list the discovered compilers as an exclude pattern!
44043 44043 # If we do that, we can do this detection before POST_DETECTION, and still
44044 44044 # find the build compilers in the tools dir, if needed.
44045 44045
44046 44046
44047 44047
44048 44048 # Publish this variable in the help.
44049 44049
44050 44050
44051 44051 if [ -z "${BUILD_CC+x}" ]; then
44052 44052 # The variable is not set by user, try to locate tool using the code snippet
44053 44053 for ac_prog in cl cc gcc
44054 44054 do
44055 44055 # Extract the first word of "$ac_prog", so it can be a program name with args.
44056 44056 set dummy $ac_prog; ac_word=$2
44057 44057 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44058 44058 $as_echo_n "checking for $ac_word... " >&6; }
44059 44059 if ${ac_cv_path_BUILD_CC+:} false; then :
44060 44060 $as_echo_n "(cached) " >&6
44061 44061 else
44062 44062 case $BUILD_CC in
44063 44063 [\\/]* | ?:[\\/]*)
44064 44064 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
44065 44065 ;;
44066 44066 *)
44067 44067 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44068 44068 for as_dir in $PATH
44069 44069 do
44070 44070 IFS=$as_save_IFS
44071 44071 test -z "$as_dir" && as_dir=.
44072 44072 for ac_exec_ext in '' $ac_executable_extensions; do
44073 44073 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44074 44074 ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
44075 44075 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44076 44076 break 2
44077 44077 fi
44078 44078 done
44079 44079 done
44080 44080 IFS=$as_save_IFS
44081 44081
44082 44082 ;;
44083 44083 esac
44084 44084 fi
44085 44085 BUILD_CC=$ac_cv_path_BUILD_CC
44086 44086 if test -n "$BUILD_CC"; then
44087 44087 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
44088 44088 $as_echo "$BUILD_CC" >&6; }
44089 44089 else
44090 44090 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44091 44091 $as_echo "no" >&6; }
44092 44092 fi
44093 44093
44094 44094
44095 44095 test -n "$BUILD_CC" && break
44096 44096 done
44097 44097
44098 44098 else
44099 44099 # The variable is set, but is it from the command line or the environment?
44100 44100
44101 44101 # Try to remove the string !BUILD_CC! from our list.
44102 44102 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CC!/}
44103 44103 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
44104 44104 # If it failed, the variable was not from the command line. Ignore it,
44105 44105 # but warn the user (except for BASH, which is always set by the calling BASH).
44106 44106 if test "xBUILD_CC" != xBASH; then
44107 44107 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
44108 44108 $as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
44109 44109 fi
44110 44110 # Try to locate tool using the code snippet
44111 44111 for ac_prog in cl cc gcc
44112 44112 do
44113 44113 # Extract the first word of "$ac_prog", so it can be a program name with args.
44114 44114 set dummy $ac_prog; ac_word=$2
44115 44115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44116 44116 $as_echo_n "checking for $ac_word... " >&6; }
44117 44117 if ${ac_cv_path_BUILD_CC+:} false; then :
44118 44118 $as_echo_n "(cached) " >&6
44119 44119 else
44120 44120 case $BUILD_CC in
44121 44121 [\\/]* | ?:[\\/]*)
44122 44122 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
44123 44123 ;;
44124 44124 *)
44125 44125 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44126 44126 for as_dir in $PATH
44127 44127 do
44128 44128 IFS=$as_save_IFS
44129 44129 test -z "$as_dir" && as_dir=.
44130 44130 for ac_exec_ext in '' $ac_executable_extensions; do
44131 44131 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44132 44132 ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
44133 44133 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44134 44134 break 2
44135 44135 fi
44136 44136 done
44137 44137 done
44138 44138 IFS=$as_save_IFS
44139 44139
44140 44140 ;;
44141 44141 esac
44142 44142 fi
44143 44143 BUILD_CC=$ac_cv_path_BUILD_CC
44144 44144 if test -n "$BUILD_CC"; then
44145 44145 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
44146 44146 $as_echo "$BUILD_CC" >&6; }
44147 44147 else
44148 44148 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44149 44149 $as_echo "no" >&6; }
44150 44150 fi
44151 44151
44152 44152
44153 44153 test -n "$BUILD_CC" && break
44154 44154 done
44155 44155
44156 44156 else
44157 44157 # If it succeeded, then it was overridden by the user. We will use it
44158 44158 # for the tool.
44159 44159
44160 44160 # First remove it from the list of overridden variables, so we can test
44161 44161 # for unknown variables in the end.
44162 44162 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
44163 44163
44164 44164 # Check if we try to supply an empty value
44165 44165 if test "x$BUILD_CC" = x; then
44166 44166 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_CC= (no value)" >&5
44167 44167 $as_echo "$as_me: Setting user supplied tool BUILD_CC= (no value)" >&6;}
44168 44168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
44169 44169 $as_echo_n "checking for BUILD_CC... " >&6; }
44170 44170 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
44171 44171 $as_echo "disabled" >&6; }
44172 44172 else
44173 44173 # Check if the provided tool contains a complete path.
44174 44174 tool_specified="$BUILD_CC"
44175 44175 tool_basename="${tool_specified##*/}"
44176 44176 if test "x$tool_basename" = "x$tool_specified"; then
44177 44177 # A command without a complete path is provided, search $PATH.
44178 44178 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
44179 44179 $as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
44180 44180 # Extract the first word of "$tool_basename", so it can be a program name with args.
44181 44181 set dummy $tool_basename; ac_word=$2
44182 44182 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44183 44183 $as_echo_n "checking for $ac_word... " >&6; }
44184 44184 if ${ac_cv_path_BUILD_CC+:} false; then :
44185 44185 $as_echo_n "(cached) " >&6
44186 44186 else
44187 44187 case $BUILD_CC in
44188 44188 [\\/]* | ?:[\\/]*)
44189 44189 ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
44190 44190 ;;
44191 44191 *)
44192 44192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44193 44193 for as_dir in $PATH
44194 44194 do
44195 44195 IFS=$as_save_IFS
44196 44196 test -z "$as_dir" && as_dir=.
44197 44197 for ac_exec_ext in '' $ac_executable_extensions; do
44198 44198 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44199 44199 ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
44200 44200 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44201 44201 break 2
44202 44202 fi
44203 44203 done
44204 44204 done
44205 44205 IFS=$as_save_IFS
44206 44206
44207 44207 ;;
44208 44208 esac
44209 44209 fi
44210 44210 BUILD_CC=$ac_cv_path_BUILD_CC
44211 44211 if test -n "$BUILD_CC"; then
44212 44212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
44213 44213 $as_echo "$BUILD_CC" >&6; }
44214 44214 else
44215 44215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44216 44216 $as_echo "no" >&6; }
44217 44217 fi
44218 44218
44219 44219
44220 44220 if test "x$BUILD_CC" = x; then
44221 44221 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
44222 44222 fi
44223 44223 else
44224 44224 # Otherwise we believe it is a complete path. Use it as it is.
44225 44225 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
44226 44226 $as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
44227 44227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
44228 44228 $as_echo_n "checking for BUILD_CC... " >&6; }
44229 44229 if test ! -x "$tool_specified"; then
44230 44230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
44231 44231 $as_echo "not found" >&6; }
44232 44232 as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
44233 44233 fi
44234 44234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
44235 44235 $as_echo "$tool_specified" >&6; }
44236 44236 fi
44237 44237 fi
44238 44238 fi
44239 44239
44240 44240 fi
44241 44241
44242 44242
44243 44243
44244 44244 if test "x$BUILD_CC" = x; then
44245 44245 as_fn_error $? "Could not find required tool for BUILD_CC" "$LINENO" 5
44246 44246 fi
44247 44247
44248 44248
44249 44249
44250 44250 # Only process if variable expands to non-empty
44251 44251
44252 44252 if test "x$BUILD_CC" != x; then
44253 44253 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44254 44254
44255 44255 # First separate the path from the arguments. This will split at the first
44256 44256 # space.
44257 44257 complete="$BUILD_CC"
44258 44258 path="${complete%% *}"
44259 44259 tmp="$complete EOL"
44260 44260 arguments="${tmp#* }"
44261 44261
44262 44262 # Input might be given as Windows format, start by converting to
44263 44263 # unix format.
44264 44264 new_path=`$CYGPATH -u "$path"`
44265 44265
44266 44266 # Now try to locate executable using which
44267 44267 new_path=`$WHICH "$new_path" 2> /dev/null`
44268 44268 # bat and cmd files are not always considered executable in cygwin causing which
44269 44269 # to not find them
44270 44270 if test "x$new_path" = x \
44271 44271 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44272 44272 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44273 44273 new_path=`$CYGPATH -u "$path"`
44274 44274 fi
44275 44275 if test "x$new_path" = x; then
44276 44276 # Oops. Which didn't find the executable.
44277 44277 # The splitting of arguments from the executable at a space might have been incorrect,
44278 44278 # since paths with space are more likely in Windows. Give it another try with the whole
44279 44279 # argument.
44280 44280 path="$complete"
44281 44281 arguments="EOL"
44282 44282 new_path=`$CYGPATH -u "$path"`
44283 44283 new_path=`$WHICH "$new_path" 2> /dev/null`
44284 44284 # bat and cmd files are not always considered executable in cygwin causing which
44285 44285 # to not find them
44286 44286 if test "x$new_path" = x \
44287 44287 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44288 44288 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44289 44289 new_path=`$CYGPATH -u "$path"`
44290 44290 fi
44291 44291 if test "x$new_path" = x; then
44292 44292 # It's still not found. Now this is an unrecoverable error.
44293 44293 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
44294 44294 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
44295 44295 has_space=`$ECHO "$complete" | $GREP " "`
44296 44296 if test "x$has_space" != x; then
44297 44297 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
44298 44298 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
44299 44299 fi
44300 44300 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
44301 44301 fi
44302 44302 fi
44303 44303
44304 44304 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
44305 44305 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
44306 44306 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
44307 44307 # "foo.exe" is OK but "foo" is an error.
44308 44308 #
44309 44309 # This test is therefore slightly more accurate than "test -f" to check for file presence.
44310 44310 # It is also a way to make sure we got the proper file name for the real test later on.
44311 44311 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
44312 44312 if test "x$test_shortpath" = x; then
44313 44313 # Short path failed, file does not exist as specified.
44314 44314 # Try adding .exe or .cmd
44315 44315 if test -f "${new_path}.exe"; then
44316 44316 input_to_shortpath="${new_path}.exe"
44317 44317 elif test -f "${new_path}.cmd"; then
44318 44318 input_to_shortpath="${new_path}.cmd"
44319 44319 else
44320 44320 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
44321 44321 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
44322 44322 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
44323 44323 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
44324 44324 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
44325 44325 fi
44326 44326 else
44327 44327 input_to_shortpath="$new_path"
44328 44328 fi
44329 44329
44330 44330 # Call helper function which possibly converts this using DOS-style short mode.
44331 44331 # If so, the updated path is stored in $new_path.
44332 44332 new_path="$input_to_shortpath"
44333 44333
44334 44334 input_path="$input_to_shortpath"
44335 44335 # Check if we need to convert this using DOS-style short mode. If the path
44336 44336 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44337 44337 # take no chances and rewrite it.
44338 44338 # Note: m4 eats our [], so we need to use [ and ] instead.
44339 44339 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44340 44340 if test "x$has_forbidden_chars" != x; then
44341 44341 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44342 44342 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44343 44343 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44344 44344 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44345 44345 # Going to short mode and back again did indeed matter. Since short mode is
44346 44346 # case insensitive, let's make it lowercase to improve readability.
44347 44347 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44348 44348 # Now convert it back to Unix-style (cygpath)
44349 44349 input_path=`$CYGPATH -u "$shortmode_path"`
44350 44350 new_path="$input_path"
44351 44351 fi
44352 44352 fi
44353 44353
44354 44354 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44355 44355 if test "x$test_cygdrive_prefix" = x; then
44356 44356 # As a simple fix, exclude /usr/bin since it's not a real path.
44357 44357 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
44358 44358 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44359 44359 # a path prefixed by /cygdrive for fixpath to work.
44360 44360 new_path="$CYGWIN_ROOT_PATH$input_path"
44361 44361 fi
44362 44362 fi
44363 44363
44364 44364 # remove trailing .exe if any
44365 44365 new_path="${new_path/%.exe/}"
44366 44366
44367 44367 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44368 44368
44369 44369 # First separate the path from the arguments. This will split at the first
44370 44370 # space.
44371 44371 complete="$BUILD_CC"
44372 44372 path="${complete%% *}"
44373 44373 tmp="$complete EOL"
44374 44374 arguments="${tmp#* }"
44375 44375
44376 44376 # Input might be given as Windows format, start by converting to
44377 44377 # unix format.
44378 44378 new_path="$path"
44379 44379
44380 44380 windows_path="$new_path"
44381 44381 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44382 44382 unix_path=`$CYGPATH -u "$windows_path"`
44383 44383 new_path="$unix_path"
44384 44384 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44385 44385 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44386 44386 new_path="$unix_path"
44387 44387 fi
44388 44388
44389 44389
44390 44390 # Now try to locate executable using which
44391 44391 new_path=`$WHICH "$new_path" 2> /dev/null`
44392 44392
44393 44393 if test "x$new_path" = x; then
44394 44394 # Oops. Which didn't find the executable.
44395 44395 # The splitting of arguments from the executable at a space might have been incorrect,
44396 44396 # since paths with space are more likely in Windows. Give it another try with the whole
44397 44397 # argument.
44398 44398 path="$complete"
44399 44399 arguments="EOL"
44400 44400 new_path="$path"
44401 44401
44402 44402 windows_path="$new_path"
44403 44403 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44404 44404 unix_path=`$CYGPATH -u "$windows_path"`
44405 44405 new_path="$unix_path"
44406 44406 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44407 44407 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44408 44408 new_path="$unix_path"
44409 44409 fi
44410 44410
44411 44411
44412 44412 new_path=`$WHICH "$new_path" 2> /dev/null`
44413 44413 # bat and cmd files are not always considered executable in MSYS causing which
44414 44414 # to not find them
44415 44415 if test "x$new_path" = x \
44416 44416 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44417 44417 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44418 44418 new_path="$path"
44419 44419
44420 44420 windows_path="$new_path"
44421 44421 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44422 44422 unix_path=`$CYGPATH -u "$windows_path"`
44423 44423 new_path="$unix_path"
44424 44424 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44425 44425 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44426 44426 new_path="$unix_path"
44427 44427 fi
44428 44428
44429 44429 fi
44430 44430
44431 44431 if test "x$new_path" = x; then
44432 44432 # It's still not found. Now this is an unrecoverable error.
44433 44433 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
44434 44434 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
44435 44435 has_space=`$ECHO "$complete" | $GREP " "`
44436 44436 if test "x$has_space" != x; then
44437 44437 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
44438 44438 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
44439 44439 fi
44440 44440 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
44441 44441 fi
44442 44442 fi
44443 44443
44444 44444 # Now new_path has a complete unix path to the binary
44445 44445 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
44446 44446 # Keep paths in /bin as-is, but remove trailing .exe if any
44447 44447 new_path="${new_path/%.exe/}"
44448 44448 # Do not save /bin paths to all_fixpath_prefixes!
44449 44449 else
44450 44450 # Not in mixed or Windows style, start by that.
44451 44451 new_path=`cmd //c echo $new_path`
44452 44452
44453 44453 input_path="$new_path"
44454 44454 # Check if we need to convert this using DOS-style short mode. If the path
44455 44455 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44456 44456 # take no chances and rewrite it.
44457 44457 # Note: m4 eats our [], so we need to use [ and ] instead.
44458 44458 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
44459 44459 if test "x$has_forbidden_chars" != x; then
44460 44460 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44461 44461 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44462 44462 fi
44463 44463
44464 44464 # Output is in $new_path
44465 44465
44466 44466 windows_path="$new_path"
44467 44467 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44468 44468 unix_path=`$CYGPATH -u "$windows_path"`
44469 44469 new_path="$unix_path"
44470 44470 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44471 44471 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44472 44472 new_path="$unix_path"
44473 44473 fi
44474 44474
44475 44475 # remove trailing .exe if any
44476 44476 new_path="${new_path/%.exe/}"
44477 44477
44478 44478 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44479 44479 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44480 44480 fi
44481 44481
44482 44482 else
44483 44483 # We're on a unix platform. Hooray! :)
44484 44484 # First separate the path from the arguments. This will split at the first
44485 44485 # space.
44486 44486 complete="$BUILD_CC"
44487 44487 path="${complete%% *}"
44488 44488 tmp="$complete EOL"
44489 44489 arguments="${tmp#* }"
44490 44490
44491 44491 # Cannot rely on the command "which" here since it doesn't always work.
44492 44492 is_absolute_path=`$ECHO "$path" | $GREP ^/`
44493 44493 if test -z "$is_absolute_path"; then
44494 44494 # Path to executable is not absolute. Find it.
44495 44495 IFS_save="$IFS"
44496 44496 IFS=:
44497 44497 for p in $PATH; do
44498 44498 if test -f "$p/$path" && test -x "$p/$path"; then
44499 44499 new_path="$p/$path"
44500 44500 break
44501 44501 fi
44502 44502 done
44503 44503 IFS="$IFS_save"
44504 44504 else
44505 44505 # This is an absolute path, we can use it without further modifications.
44506 44506 new_path="$path"
44507 44507 fi
44508 44508
44509 44509 if test "x$new_path" = x; then
44510 44510 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
44511 44511 $as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
44512 44512 has_space=`$ECHO "$complete" | $GREP " "`
44513 44513 if test "x$has_space" != x; then
44514 44514 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
44515 44515 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
44516 44516 fi
44517 44517 as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
44518 44518 fi
44519 44519 fi
44520 44520
44521 44521 # Now join together the path and the arguments once again
44522 44522 if test "x$arguments" != xEOL; then
44523 44523 new_complete="$new_path ${arguments% *}"
44524 44524 else
44525 44525 new_complete="$new_path"
44526 44526 fi
44527 44527
44528 44528 if test "x$complete" != "x$new_complete"; then
44529 44529 BUILD_CC="$new_complete"
44530 44530 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
44531 44531 $as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
44532 44532 fi
44533 44533 fi
44534 44534
44535 44535
44536 44536
44537 44537
44538 44538 # Publish this variable in the help.
44539 44539
44540 44540
44541 44541 if [ -z "${BUILD_CXX+x}" ]; then
44542 44542 # The variable is not set by user, try to locate tool using the code snippet
44543 44543 for ac_prog in cl CC g++
44544 44544 do
44545 44545 # Extract the first word of "$ac_prog", so it can be a program name with args.
44546 44546 set dummy $ac_prog; ac_word=$2
44547 44547 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44548 44548 $as_echo_n "checking for $ac_word... " >&6; }
44549 44549 if ${ac_cv_path_BUILD_CXX+:} false; then :
44550 44550 $as_echo_n "(cached) " >&6
44551 44551 else
44552 44552 case $BUILD_CXX in
44553 44553 [\\/]* | ?:[\\/]*)
44554 44554 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
44555 44555 ;;
44556 44556 *)
44557 44557 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44558 44558 for as_dir in $PATH
44559 44559 do
44560 44560 IFS=$as_save_IFS
44561 44561 test -z "$as_dir" && as_dir=.
44562 44562 for ac_exec_ext in '' $ac_executable_extensions; do
44563 44563 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44564 44564 ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
44565 44565 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44566 44566 break 2
44567 44567 fi
44568 44568 done
44569 44569 done
44570 44570 IFS=$as_save_IFS
44571 44571
44572 44572 ;;
44573 44573 esac
44574 44574 fi
44575 44575 BUILD_CXX=$ac_cv_path_BUILD_CXX
44576 44576 if test -n "$BUILD_CXX"; then
44577 44577 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
44578 44578 $as_echo "$BUILD_CXX" >&6; }
44579 44579 else
44580 44580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44581 44581 $as_echo "no" >&6; }
44582 44582 fi
44583 44583
44584 44584
44585 44585 test -n "$BUILD_CXX" && break
44586 44586 done
44587 44587
44588 44588 else
44589 44589 # The variable is set, but is it from the command line or the environment?
44590 44590
44591 44591 # Try to remove the string !BUILD_CXX! from our list.
44592 44592 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CXX!/}
44593 44593 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
44594 44594 # If it failed, the variable was not from the command line. Ignore it,
44595 44595 # but warn the user (except for BASH, which is always set by the calling BASH).
44596 44596 if test "xBUILD_CXX" != xBASH; then
44597 44597 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
44598 44598 $as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
44599 44599 fi
44600 44600 # Try to locate tool using the code snippet
44601 44601 for ac_prog in cl CC g++
44602 44602 do
44603 44603 # Extract the first word of "$ac_prog", so it can be a program name with args.
44604 44604 set dummy $ac_prog; ac_word=$2
44605 44605 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44606 44606 $as_echo_n "checking for $ac_word... " >&6; }
44607 44607 if ${ac_cv_path_BUILD_CXX+:} false; then :
44608 44608 $as_echo_n "(cached) " >&6
44609 44609 else
44610 44610 case $BUILD_CXX in
44611 44611 [\\/]* | ?:[\\/]*)
44612 44612 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
44613 44613 ;;
44614 44614 *)
44615 44615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44616 44616 for as_dir in $PATH
44617 44617 do
44618 44618 IFS=$as_save_IFS
44619 44619 test -z "$as_dir" && as_dir=.
44620 44620 for ac_exec_ext in '' $ac_executable_extensions; do
44621 44621 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44622 44622 ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
44623 44623 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44624 44624 break 2
44625 44625 fi
44626 44626 done
44627 44627 done
44628 44628 IFS=$as_save_IFS
44629 44629
44630 44630 ;;
44631 44631 esac
44632 44632 fi
44633 44633 BUILD_CXX=$ac_cv_path_BUILD_CXX
44634 44634 if test -n "$BUILD_CXX"; then
44635 44635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
44636 44636 $as_echo "$BUILD_CXX" >&6; }
44637 44637 else
44638 44638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44639 44639 $as_echo "no" >&6; }
44640 44640 fi
44641 44641
44642 44642
44643 44643 test -n "$BUILD_CXX" && break
44644 44644 done
44645 44645
44646 44646 else
44647 44647 # If it succeeded, then it was overridden by the user. We will use it
44648 44648 # for the tool.
44649 44649
44650 44650 # First remove it from the list of overridden variables, so we can test
44651 44651 # for unknown variables in the end.
44652 44652 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
44653 44653
44654 44654 # Check if we try to supply an empty value
44655 44655 if test "x$BUILD_CXX" = x; then
44656 44656 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_CXX= (no value)" >&5
44657 44657 $as_echo "$as_me: Setting user supplied tool BUILD_CXX= (no value)" >&6;}
44658 44658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
44659 44659 $as_echo_n "checking for BUILD_CXX... " >&6; }
44660 44660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
44661 44661 $as_echo "disabled" >&6; }
44662 44662 else
44663 44663 # Check if the provided tool contains a complete path.
44664 44664 tool_specified="$BUILD_CXX"
44665 44665 tool_basename="${tool_specified##*/}"
44666 44666 if test "x$tool_basename" = "x$tool_specified"; then
44667 44667 # A command without a complete path is provided, search $PATH.
44668 44668 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
44669 44669 $as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
44670 44670 # Extract the first word of "$tool_basename", so it can be a program name with args.
44671 44671 set dummy $tool_basename; ac_word=$2
44672 44672 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
44673 44673 $as_echo_n "checking for $ac_word... " >&6; }
44674 44674 if ${ac_cv_path_BUILD_CXX+:} false; then :
44675 44675 $as_echo_n "(cached) " >&6
44676 44676 else
44677 44677 case $BUILD_CXX in
44678 44678 [\\/]* | ?:[\\/]*)
44679 44679 ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
44680 44680 ;;
44681 44681 *)
44682 44682 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
44683 44683 for as_dir in $PATH
44684 44684 do
44685 44685 IFS=$as_save_IFS
44686 44686 test -z "$as_dir" && as_dir=.
44687 44687 for ac_exec_ext in '' $ac_executable_extensions; do
44688 44688 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
44689 44689 ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
44690 44690 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
44691 44691 break 2
44692 44692 fi
44693 44693 done
44694 44694 done
44695 44695 IFS=$as_save_IFS
44696 44696
44697 44697 ;;
44698 44698 esac
44699 44699 fi
44700 44700 BUILD_CXX=$ac_cv_path_BUILD_CXX
44701 44701 if test -n "$BUILD_CXX"; then
44702 44702 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
44703 44703 $as_echo "$BUILD_CXX" >&6; }
44704 44704 else
44705 44705 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
44706 44706 $as_echo "no" >&6; }
44707 44707 fi
44708 44708
44709 44709
44710 44710 if test "x$BUILD_CXX" = x; then
44711 44711 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
44712 44712 fi
44713 44713 else
44714 44714 # Otherwise we believe it is a complete path. Use it as it is.
44715 44715 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
44716 44716 $as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
44717 44717 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
44718 44718 $as_echo_n "checking for BUILD_CXX... " >&6; }
44719 44719 if test ! -x "$tool_specified"; then
44720 44720 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
44721 44721 $as_echo "not found" >&6; }
44722 44722 as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
44723 44723 fi
44724 44724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
44725 44725 $as_echo "$tool_specified" >&6; }
44726 44726 fi
44727 44727 fi
44728 44728 fi
44729 44729
44730 44730 fi
44731 44731
44732 44732
44733 44733
44734 44734 if test "x$BUILD_CXX" = x; then
44735 44735 as_fn_error $? "Could not find required tool for BUILD_CXX" "$LINENO" 5
44736 44736 fi
44737 44737
44738 44738
44739 44739
44740 44740 # Only process if variable expands to non-empty
44741 44741
44742 44742 if test "x$BUILD_CXX" != x; then
44743 44743 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44744 44744
44745 44745 # First separate the path from the arguments. This will split at the first
44746 44746 # space.
44747 44747 complete="$BUILD_CXX"
44748 44748 path="${complete%% *}"
44749 44749 tmp="$complete EOL"
44750 44750 arguments="${tmp#* }"
44751 44751
44752 44752 # Input might be given as Windows format, start by converting to
44753 44753 # unix format.
44754 44754 new_path=`$CYGPATH -u "$path"`
44755 44755
44756 44756 # Now try to locate executable using which
44757 44757 new_path=`$WHICH "$new_path" 2> /dev/null`
44758 44758 # bat and cmd files are not always considered executable in cygwin causing which
44759 44759 # to not find them
44760 44760 if test "x$new_path" = x \
44761 44761 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44762 44762 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44763 44763 new_path=`$CYGPATH -u "$path"`
44764 44764 fi
44765 44765 if test "x$new_path" = x; then
44766 44766 # Oops. Which didn't find the executable.
44767 44767 # The splitting of arguments from the executable at a space might have been incorrect,
44768 44768 # since paths with space are more likely in Windows. Give it another try with the whole
44769 44769 # argument.
44770 44770 path="$complete"
44771 44771 arguments="EOL"
44772 44772 new_path=`$CYGPATH -u "$path"`
44773 44773 new_path=`$WHICH "$new_path" 2> /dev/null`
44774 44774 # bat and cmd files are not always considered executable in cygwin causing which
44775 44775 # to not find them
44776 44776 if test "x$new_path" = x \
44777 44777 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44778 44778 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44779 44779 new_path=`$CYGPATH -u "$path"`
44780 44780 fi
44781 44781 if test "x$new_path" = x; then
44782 44782 # It's still not found. Now this is an unrecoverable error.
44783 44783 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
44784 44784 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
44785 44785 has_space=`$ECHO "$complete" | $GREP " "`
44786 44786 if test "x$has_space" != x; then
44787 44787 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
44788 44788 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
44789 44789 fi
44790 44790 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
44791 44791 fi
44792 44792 fi
44793 44793
44794 44794 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
44795 44795 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
44796 44796 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
44797 44797 # "foo.exe" is OK but "foo" is an error.
44798 44798 #
44799 44799 # This test is therefore slightly more accurate than "test -f" to check for file presence.
44800 44800 # It is also a way to make sure we got the proper file name for the real test later on.
44801 44801 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
44802 44802 if test "x$test_shortpath" = x; then
44803 44803 # Short path failed, file does not exist as specified.
44804 44804 # Try adding .exe or .cmd
44805 44805 if test -f "${new_path}.exe"; then
44806 44806 input_to_shortpath="${new_path}.exe"
44807 44807 elif test -f "${new_path}.cmd"; then
44808 44808 input_to_shortpath="${new_path}.cmd"
44809 44809 else
44810 44810 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
44811 44811 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
44812 44812 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
44813 44813 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
44814 44814 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
44815 44815 fi
44816 44816 else
44817 44817 input_to_shortpath="$new_path"
44818 44818 fi
44819 44819
44820 44820 # Call helper function which possibly converts this using DOS-style short mode.
44821 44821 # If so, the updated path is stored in $new_path.
44822 44822 new_path="$input_to_shortpath"
44823 44823
44824 44824 input_path="$input_to_shortpath"
44825 44825 # Check if we need to convert this using DOS-style short mode. If the path
44826 44826 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44827 44827 # take no chances and rewrite it.
44828 44828 # Note: m4 eats our [], so we need to use [ and ] instead.
44829 44829 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44830 44830 if test "x$has_forbidden_chars" != x; then
44831 44831 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44832 44832 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44833 44833 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44834 44834 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44835 44835 # Going to short mode and back again did indeed matter. Since short mode is
44836 44836 # case insensitive, let's make it lowercase to improve readability.
44837 44837 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44838 44838 # Now convert it back to Unix-style (cygpath)
44839 44839 input_path=`$CYGPATH -u "$shortmode_path"`
44840 44840 new_path="$input_path"
44841 44841 fi
44842 44842 fi
44843 44843
44844 44844 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44845 44845 if test "x$test_cygdrive_prefix" = x; then
44846 44846 # As a simple fix, exclude /usr/bin since it's not a real path.
44847 44847 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
44848 44848 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44849 44849 # a path prefixed by /cygdrive for fixpath to work.
44850 44850 new_path="$CYGWIN_ROOT_PATH$input_path"
44851 44851 fi
44852 44852 fi
44853 44853
44854 44854 # remove trailing .exe if any
44855 44855 new_path="${new_path/%.exe/}"
44856 44856
44857 44857 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44858 44858
44859 44859 # First separate the path from the arguments. This will split at the first
44860 44860 # space.
44861 44861 complete="$BUILD_CXX"
44862 44862 path="${complete%% *}"
44863 44863 tmp="$complete EOL"
44864 44864 arguments="${tmp#* }"
44865 44865
44866 44866 # Input might be given as Windows format, start by converting to
44867 44867 # unix format.
44868 44868 new_path="$path"
44869 44869
44870 44870 windows_path="$new_path"
44871 44871 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44872 44872 unix_path=`$CYGPATH -u "$windows_path"`
44873 44873 new_path="$unix_path"
44874 44874 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44875 44875 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44876 44876 new_path="$unix_path"
44877 44877 fi
44878 44878
44879 44879
44880 44880 # Now try to locate executable using which
44881 44881 new_path=`$WHICH "$new_path" 2> /dev/null`
44882 44882
44883 44883 if test "x$new_path" = x; then
44884 44884 # Oops. Which didn't find the executable.
44885 44885 # The splitting of arguments from the executable at a space might have been incorrect,
44886 44886 # since paths with space are more likely in Windows. Give it another try with the whole
44887 44887 # argument.
44888 44888 path="$complete"
44889 44889 arguments="EOL"
44890 44890 new_path="$path"
44891 44891
44892 44892 windows_path="$new_path"
44893 44893 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44894 44894 unix_path=`$CYGPATH -u "$windows_path"`
44895 44895 new_path="$unix_path"
44896 44896 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44897 44897 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44898 44898 new_path="$unix_path"
44899 44899 fi
44900 44900
44901 44901
44902 44902 new_path=`$WHICH "$new_path" 2> /dev/null`
44903 44903 # bat and cmd files are not always considered executable in MSYS causing which
44904 44904 # to not find them
44905 44905 if test "x$new_path" = x \
44906 44906 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
44907 44907 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
44908 44908 new_path="$path"
44909 44909
44910 44910 windows_path="$new_path"
44911 44911 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44912 44912 unix_path=`$CYGPATH -u "$windows_path"`
44913 44913 new_path="$unix_path"
44914 44914 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44915 44915 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44916 44916 new_path="$unix_path"
44917 44917 fi
44918 44918
44919 44919 fi
44920 44920
44921 44921 if test "x$new_path" = x; then
44922 44922 # It's still not found. Now this is an unrecoverable error.
44923 44923 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
44924 44924 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
44925 44925 has_space=`$ECHO "$complete" | $GREP " "`
44926 44926 if test "x$has_space" != x; then
44927 44927 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
44928 44928 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
44929 44929 fi
44930 44930 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
44931 44931 fi
44932 44932 fi
44933 44933
44934 44934 # Now new_path has a complete unix path to the binary
44935 44935 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
44936 44936 # Keep paths in /bin as-is, but remove trailing .exe if any
44937 44937 new_path="${new_path/%.exe/}"
44938 44938 # Do not save /bin paths to all_fixpath_prefixes!
44939 44939 else
44940 44940 # Not in mixed or Windows style, start by that.
44941 44941 new_path=`cmd //c echo $new_path`
44942 44942
44943 44943 input_path="$new_path"
44944 44944 # Check if we need to convert this using DOS-style short mode. If the path
44945 44945 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44946 44946 # take no chances and rewrite it.
44947 44947 # Note: m4 eats our [], so we need to use [ and ] instead.
44948 44948 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
44949 44949 if test "x$has_forbidden_chars" != x; then
44950 44950 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44951 44951 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44952 44952 fi
44953 44953
44954 44954 # Output is in $new_path
44955 44955
44956 44956 windows_path="$new_path"
44957 44957 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44958 44958 unix_path=`$CYGPATH -u "$windows_path"`
44959 44959 new_path="$unix_path"
44960 44960 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44961 44961 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44962 44962 new_path="$unix_path"
44963 44963 fi
44964 44964
44965 44965 # remove trailing .exe if any
44966 44966 new_path="${new_path/%.exe/}"
44967 44967
44968 44968 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44969 44969 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44970 44970 fi
44971 44971
44972 44972 else
44973 44973 # We're on a unix platform. Hooray! :)
44974 44974 # First separate the path from the arguments. This will split at the first
44975 44975 # space.
44976 44976 complete="$BUILD_CXX"
44977 44977 path="${complete%% *}"
44978 44978 tmp="$complete EOL"
44979 44979 arguments="${tmp#* }"
44980 44980
44981 44981 # Cannot rely on the command "which" here since it doesn't always work.
44982 44982 is_absolute_path=`$ECHO "$path" | $GREP ^/`
44983 44983 if test -z "$is_absolute_path"; then
44984 44984 # Path to executable is not absolute. Find it.
44985 44985 IFS_save="$IFS"
44986 44986 IFS=:
44987 44987 for p in $PATH; do
44988 44988 if test -f "$p/$path" && test -x "$p/$path"; then
44989 44989 new_path="$p/$path"
44990 44990 break
44991 44991 fi
44992 44992 done
44993 44993 IFS="$IFS_save"
44994 44994 else
44995 44995 # This is an absolute path, we can use it without further modifications.
44996 44996 new_path="$path"
44997 44997 fi
44998 44998
44999 44999 if test "x$new_path" = x; then
45000 45000 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
45001 45001 $as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
45002 45002 has_space=`$ECHO "$complete" | $GREP " "`
45003 45003 if test "x$has_space" != x; then
45004 45004 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
45005 45005 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
45006 45006 fi
45007 45007 as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
45008 45008 fi
45009 45009 fi
45010 45010
45011 45011 # Now join together the path and the arguments once again
45012 45012 if test "x$arguments" != xEOL; then
45013 45013 new_complete="$new_path ${arguments% *}"
45014 45014 else
45015 45015 new_complete="$new_path"
45016 45016 fi
45017 45017
45018 45018 if test "x$complete" != "x$new_complete"; then
45019 45019 BUILD_CXX="$new_complete"
45020 45020 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
45021 45021 $as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
45022 45022 fi
45023 45023 fi
45024 45024
45025 45025
45026 45026
45027 45027 # Publish this variable in the help.
45028 45028
45029 45029
45030 45030 if [ -z "${BUILD_NM+x}" ]; then
45031 45031 # The variable is not set by user, try to locate tool using the code snippet
45032 45032 for ac_prog in nm gcc-nm
45033 45033 do
45034 45034 # Extract the first word of "$ac_prog", so it can be a program name with args.
45035 45035 set dummy $ac_prog; ac_word=$2
45036 45036 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45037 45037 $as_echo_n "checking for $ac_word... " >&6; }
45038 45038 if ${ac_cv_path_BUILD_NM+:} false; then :
45039 45039 $as_echo_n "(cached) " >&6
45040 45040 else
45041 45041 case $BUILD_NM in
45042 45042 [\\/]* | ?:[\\/]*)
45043 45043 ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
45044 45044 ;;
45045 45045 *)
45046 45046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45047 45047 for as_dir in $PATH
45048 45048 do
45049 45049 IFS=$as_save_IFS
45050 45050 test -z "$as_dir" && as_dir=.
45051 45051 for ac_exec_ext in '' $ac_executable_extensions; do
45052 45052 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45053 45053 ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
45054 45054 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45055 45055 break 2
45056 45056 fi
45057 45057 done
45058 45058 done
45059 45059 IFS=$as_save_IFS
45060 45060
45061 45061 ;;
45062 45062 esac
45063 45063 fi
45064 45064 BUILD_NM=$ac_cv_path_BUILD_NM
45065 45065 if test -n "$BUILD_NM"; then
45066 45066 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
45067 45067 $as_echo "$BUILD_NM" >&6; }
45068 45068 else
45069 45069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45070 45070 $as_echo "no" >&6; }
45071 45071 fi
45072 45072
45073 45073
45074 45074 test -n "$BUILD_NM" && break
45075 45075 done
45076 45076
45077 45077 else
45078 45078 # The variable is set, but is it from the command line or the environment?
45079 45079
45080 45080 # Try to remove the string !BUILD_NM! from our list.
45081 45081 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_NM!/}
45082 45082 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
45083 45083 # If it failed, the variable was not from the command line. Ignore it,
45084 45084 # but warn the user (except for BASH, which is always set by the calling BASH).
45085 45085 if test "xBUILD_NM" != xBASH; then
45086 45086 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_NM from the environment. Use command line variables instead." >&5
45087 45087 $as_echo "$as_me: WARNING: Ignoring value of BUILD_NM from the environment. Use command line variables instead." >&2;}
45088 45088 fi
45089 45089 # Try to locate tool using the code snippet
45090 45090 for ac_prog in nm gcc-nm
45091 45091 do
45092 45092 # Extract the first word of "$ac_prog", so it can be a program name with args.
45093 45093 set dummy $ac_prog; ac_word=$2
45094 45094 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45095 45095 $as_echo_n "checking for $ac_word... " >&6; }
45096 45096 if ${ac_cv_path_BUILD_NM+:} false; then :
45097 45097 $as_echo_n "(cached) " >&6
45098 45098 else
45099 45099 case $BUILD_NM in
45100 45100 [\\/]* | ?:[\\/]*)
45101 45101 ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
45102 45102 ;;
45103 45103 *)
45104 45104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45105 45105 for as_dir in $PATH
45106 45106 do
45107 45107 IFS=$as_save_IFS
45108 45108 test -z "$as_dir" && as_dir=.
45109 45109 for ac_exec_ext in '' $ac_executable_extensions; do
45110 45110 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45111 45111 ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
45112 45112 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45113 45113 break 2
45114 45114 fi
45115 45115 done
45116 45116 done
45117 45117 IFS=$as_save_IFS
45118 45118
45119 45119 ;;
45120 45120 esac
45121 45121 fi
45122 45122 BUILD_NM=$ac_cv_path_BUILD_NM
45123 45123 if test -n "$BUILD_NM"; then
45124 45124 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
45125 45125 $as_echo "$BUILD_NM" >&6; }
45126 45126 else
45127 45127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45128 45128 $as_echo "no" >&6; }
45129 45129 fi
45130 45130
45131 45131
45132 45132 test -n "$BUILD_NM" && break
45133 45133 done
45134 45134
45135 45135 else
45136 45136 # If it succeeded, then it was overridden by the user. We will use it
45137 45137 # for the tool.
45138 45138
45139 45139 # First remove it from the list of overridden variables, so we can test
45140 45140 # for unknown variables in the end.
45141 45141 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
45142 45142
45143 45143 # Check if we try to supply an empty value
45144 45144 if test "x$BUILD_NM" = x; then
45145 45145 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_NM= (no value)" >&5
45146 45146 $as_echo "$as_me: Setting user supplied tool BUILD_NM= (no value)" >&6;}
45147 45147 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_NM" >&5
45148 45148 $as_echo_n "checking for BUILD_NM... " >&6; }
45149 45149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
45150 45150 $as_echo "disabled" >&6; }
45151 45151 else
45152 45152 # Check if the provided tool contains a complete path.
45153 45153 tool_specified="$BUILD_NM"
45154 45154 tool_basename="${tool_specified##*/}"
45155 45155 if test "x$tool_basename" = "x$tool_specified"; then
45156 45156 # A command without a complete path is provided, search $PATH.
45157 45157 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_NM=$tool_basename" >&5
45158 45158 $as_echo "$as_me: Will search for user supplied tool BUILD_NM=$tool_basename" >&6;}
45159 45159 # Extract the first word of "$tool_basename", so it can be a program name with args.
45160 45160 set dummy $tool_basename; ac_word=$2
45161 45161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45162 45162 $as_echo_n "checking for $ac_word... " >&6; }
45163 45163 if ${ac_cv_path_BUILD_NM+:} false; then :
45164 45164 $as_echo_n "(cached) " >&6
45165 45165 else
45166 45166 case $BUILD_NM in
45167 45167 [\\/]* | ?:[\\/]*)
45168 45168 ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
45169 45169 ;;
45170 45170 *)
45171 45171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45172 45172 for as_dir in $PATH
45173 45173 do
45174 45174 IFS=$as_save_IFS
45175 45175 test -z "$as_dir" && as_dir=.
45176 45176 for ac_exec_ext in '' $ac_executable_extensions; do
45177 45177 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45178 45178 ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
45179 45179 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45180 45180 break 2
45181 45181 fi
45182 45182 done
45183 45183 done
45184 45184 IFS=$as_save_IFS
45185 45185
45186 45186 ;;
45187 45187 esac
45188 45188 fi
45189 45189 BUILD_NM=$ac_cv_path_BUILD_NM
45190 45190 if test -n "$BUILD_NM"; then
45191 45191 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
45192 45192 $as_echo "$BUILD_NM" >&6; }
45193 45193 else
45194 45194 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45195 45195 $as_echo "no" >&6; }
45196 45196 fi
45197 45197
45198 45198
45199 45199 if test "x$BUILD_NM" = x; then
45200 45200 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
45201 45201 fi
45202 45202 else
45203 45203 # Otherwise we believe it is a complete path. Use it as it is.
45204 45204 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_NM=$tool_specified" >&5
45205 45205 $as_echo "$as_me: Will use user supplied tool BUILD_NM=$tool_specified" >&6;}
45206 45206 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_NM" >&5
45207 45207 $as_echo_n "checking for BUILD_NM... " >&6; }
45208 45208 if test ! -x "$tool_specified"; then
45209 45209 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
45210 45210 $as_echo "not found" >&6; }
45211 45211 as_fn_error $? "User supplied tool BUILD_NM=$tool_specified does not exist or is not executable" "$LINENO" 5
45212 45212 fi
45213 45213 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
45214 45214 $as_echo "$tool_specified" >&6; }
45215 45215 fi
45216 45216 fi
45217 45217 fi
45218 45218
45219 45219 fi
45220 45220
45221 45221
45222 45222
45223 45223 # Only process if variable expands to non-empty
45224 45224
45225 45225 if test "x$BUILD_NM" != x; then
45226 45226 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45227 45227
45228 45228 # First separate the path from the arguments. This will split at the first
45229 45229 # space.
45230 45230 complete="$BUILD_NM"
45231 45231 path="${complete%% *}"
45232 45232 tmp="$complete EOL"
45233 45233 arguments="${tmp#* }"
45234 45234
45235 45235 # Input might be given as Windows format, start by converting to
45236 45236 # unix format.
45237 45237 new_path=`$CYGPATH -u "$path"`
45238 45238
45239 45239 # Now try to locate executable using which
45240 45240 new_path=`$WHICH "$new_path" 2> /dev/null`
45241 45241 # bat and cmd files are not always considered executable in cygwin causing which
45242 45242 # to not find them
45243 45243 if test "x$new_path" = x \
45244 45244 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45245 45245 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45246 45246 new_path=`$CYGPATH -u "$path"`
45247 45247 fi
45248 45248 if test "x$new_path" = x; then
45249 45249 # Oops. Which didn't find the executable.
45250 45250 # The splitting of arguments from the executable at a space might have been incorrect,
45251 45251 # since paths with space are more likely in Windows. Give it another try with the whole
45252 45252 # argument.
45253 45253 path="$complete"
45254 45254 arguments="EOL"
45255 45255 new_path=`$CYGPATH -u "$path"`
45256 45256 new_path=`$WHICH "$new_path" 2> /dev/null`
45257 45257 # bat and cmd files are not always considered executable in cygwin causing which
45258 45258 # to not find them
45259 45259 if test "x$new_path" = x \
45260 45260 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45261 45261 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45262 45262 new_path=`$CYGPATH -u "$path"`
45263 45263 fi
45264 45264 if test "x$new_path" = x; then
45265 45265 # It's still not found. Now this is an unrecoverable error.
45266 45266 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
45267 45267 $as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
45268 45268 has_space=`$ECHO "$complete" | $GREP " "`
45269 45269 if test "x$has_space" != x; then
45270 45270 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
45271 45271 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
45272 45272 fi
45273 45273 as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
45274 45274 fi
45275 45275 fi
45276 45276
45277 45277 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
45278 45278 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
45279 45279 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
45280 45280 # "foo.exe" is OK but "foo" is an error.
45281 45281 #
45282 45282 # This test is therefore slightly more accurate than "test -f" to check for file presence.
45283 45283 # It is also a way to make sure we got the proper file name for the real test later on.
45284 45284 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
45285 45285 if test "x$test_shortpath" = x; then
45286 45286 # Short path failed, file does not exist as specified.
45287 45287 # Try adding .exe or .cmd
45288 45288 if test -f "${new_path}.exe"; then
45289 45289 input_to_shortpath="${new_path}.exe"
45290 45290 elif test -f "${new_path}.cmd"; then
45291 45291 input_to_shortpath="${new_path}.cmd"
45292 45292 else
45293 45293 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$new_path\", is invalid." >&5
45294 45294 $as_echo "$as_me: The path of BUILD_NM, which resolves as \"$new_path\", is invalid." >&6;}
45295 45295 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
45296 45296 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
45297 45297 as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
45298 45298 fi
45299 45299 else
45300 45300 input_to_shortpath="$new_path"
45301 45301 fi
45302 45302
45303 45303 # Call helper function which possibly converts this using DOS-style short mode.
45304 45304 # If so, the updated path is stored in $new_path.
45305 45305 new_path="$input_to_shortpath"
45306 45306
45307 45307 input_path="$input_to_shortpath"
45308 45308 # Check if we need to convert this using DOS-style short mode. If the path
45309 45309 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45310 45310 # take no chances and rewrite it.
45311 45311 # Note: m4 eats our [], so we need to use [ and ] instead.
45312 45312 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45313 45313 if test "x$has_forbidden_chars" != x; then
45314 45314 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45315 45315 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45316 45316 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45317 45317 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45318 45318 # Going to short mode and back again did indeed matter. Since short mode is
45319 45319 # case insensitive, let's make it lowercase to improve readability.
45320 45320 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45321 45321 # Now convert it back to Unix-style (cygpath)
45322 45322 input_path=`$CYGPATH -u "$shortmode_path"`
45323 45323 new_path="$input_path"
45324 45324 fi
45325 45325 fi
45326 45326
45327 45327 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45328 45328 if test "x$test_cygdrive_prefix" = x; then
45329 45329 # As a simple fix, exclude /usr/bin since it's not a real path.
45330 45330 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
45331 45331 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45332 45332 # a path prefixed by /cygdrive for fixpath to work.
45333 45333 new_path="$CYGWIN_ROOT_PATH$input_path"
45334 45334 fi
45335 45335 fi
45336 45336
45337 45337 # remove trailing .exe if any
45338 45338 new_path="${new_path/%.exe/}"
45339 45339
45340 45340 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45341 45341
45342 45342 # First separate the path from the arguments. This will split at the first
45343 45343 # space.
45344 45344 complete="$BUILD_NM"
45345 45345 path="${complete%% *}"
45346 45346 tmp="$complete EOL"
45347 45347 arguments="${tmp#* }"
45348 45348
45349 45349 # Input might be given as Windows format, start by converting to
45350 45350 # unix format.
45351 45351 new_path="$path"
45352 45352
45353 45353 windows_path="$new_path"
45354 45354 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45355 45355 unix_path=`$CYGPATH -u "$windows_path"`
45356 45356 new_path="$unix_path"
45357 45357 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45358 45358 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45359 45359 new_path="$unix_path"
45360 45360 fi
45361 45361
45362 45362
45363 45363 # Now try to locate executable using which
45364 45364 new_path=`$WHICH "$new_path" 2> /dev/null`
45365 45365
45366 45366 if test "x$new_path" = x; then
45367 45367 # Oops. Which didn't find the executable.
45368 45368 # The splitting of arguments from the executable at a space might have been incorrect,
45369 45369 # since paths with space are more likely in Windows. Give it another try with the whole
45370 45370 # argument.
45371 45371 path="$complete"
45372 45372 arguments="EOL"
45373 45373 new_path="$path"
45374 45374
45375 45375 windows_path="$new_path"
45376 45376 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45377 45377 unix_path=`$CYGPATH -u "$windows_path"`
45378 45378 new_path="$unix_path"
45379 45379 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45380 45380 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45381 45381 new_path="$unix_path"
45382 45382 fi
45383 45383
45384 45384
45385 45385 new_path=`$WHICH "$new_path" 2> /dev/null`
45386 45386 # bat and cmd files are not always considered executable in MSYS causing which
45387 45387 # to not find them
45388 45388 if test "x$new_path" = x \
45389 45389 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45390 45390 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45391 45391 new_path="$path"
45392 45392
45393 45393 windows_path="$new_path"
45394 45394 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45395 45395 unix_path=`$CYGPATH -u "$windows_path"`
45396 45396 new_path="$unix_path"
45397 45397 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45398 45398 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45399 45399 new_path="$unix_path"
45400 45400 fi
45401 45401
45402 45402 fi
45403 45403
45404 45404 if test "x$new_path" = x; then
45405 45405 # It's still not found. Now this is an unrecoverable error.
45406 45406 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
45407 45407 $as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
45408 45408 has_space=`$ECHO "$complete" | $GREP " "`
45409 45409 if test "x$has_space" != x; then
45410 45410 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
45411 45411 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
45412 45412 fi
45413 45413 as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
45414 45414 fi
45415 45415 fi
45416 45416
45417 45417 # Now new_path has a complete unix path to the binary
45418 45418 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
45419 45419 # Keep paths in /bin as-is, but remove trailing .exe if any
45420 45420 new_path="${new_path/%.exe/}"
45421 45421 # Do not save /bin paths to all_fixpath_prefixes!
45422 45422 else
45423 45423 # Not in mixed or Windows style, start by that.
45424 45424 new_path=`cmd //c echo $new_path`
45425 45425
45426 45426 input_path="$new_path"
45427 45427 # Check if we need to convert this using DOS-style short mode. If the path
45428 45428 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45429 45429 # take no chances and rewrite it.
45430 45430 # Note: m4 eats our [], so we need to use [ and ] instead.
45431 45431 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
45432 45432 if test "x$has_forbidden_chars" != x; then
45433 45433 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45434 45434 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45435 45435 fi
45436 45436
45437 45437 # Output is in $new_path
45438 45438
45439 45439 windows_path="$new_path"
45440 45440 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45441 45441 unix_path=`$CYGPATH -u "$windows_path"`
45442 45442 new_path="$unix_path"
45443 45443 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45444 45444 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45445 45445 new_path="$unix_path"
45446 45446 fi
45447 45447
45448 45448 # remove trailing .exe if any
45449 45449 new_path="${new_path/%.exe/}"
45450 45450
45451 45451 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45452 45452 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45453 45453 fi
45454 45454
45455 45455 else
45456 45456 # We're on a unix platform. Hooray! :)
45457 45457 # First separate the path from the arguments. This will split at the first
45458 45458 # space.
45459 45459 complete="$BUILD_NM"
45460 45460 path="${complete%% *}"
45461 45461 tmp="$complete EOL"
45462 45462 arguments="${tmp#* }"
45463 45463
45464 45464 # Cannot rely on the command "which" here since it doesn't always work.
45465 45465 is_absolute_path=`$ECHO "$path" | $GREP ^/`
45466 45466 if test -z "$is_absolute_path"; then
45467 45467 # Path to executable is not absolute. Find it.
45468 45468 IFS_save="$IFS"
45469 45469 IFS=:
45470 45470 for p in $PATH; do
45471 45471 if test -f "$p/$path" && test -x "$p/$path"; then
45472 45472 new_path="$p/$path"
45473 45473 break
45474 45474 fi
45475 45475 done
45476 45476 IFS="$IFS_save"
45477 45477 else
45478 45478 # This is an absolute path, we can use it without further modifications.
45479 45479 new_path="$path"
45480 45480 fi
45481 45481
45482 45482 if test "x$new_path" = x; then
45483 45483 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
45484 45484 $as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
45485 45485 has_space=`$ECHO "$complete" | $GREP " "`
45486 45486 if test "x$has_space" != x; then
45487 45487 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
45488 45488 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
45489 45489 fi
45490 45490 as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
45491 45491 fi
45492 45492 fi
45493 45493
45494 45494 # Now join together the path and the arguments once again
45495 45495 if test "x$arguments" != xEOL; then
45496 45496 new_complete="$new_path ${arguments% *}"
45497 45497 else
45498 45498 new_complete="$new_path"
45499 45499 fi
45500 45500
45501 45501 if test "x$complete" != "x$new_complete"; then
45502 45502 BUILD_NM="$new_complete"
45503 45503 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_NM to \"$new_complete\"" >&5
45504 45504 $as_echo "$as_me: Rewriting BUILD_NM to \"$new_complete\"" >&6;}
45505 45505 fi
45506 45506 fi
45507 45507
45508 45508
45509 45509
45510 45510 # Publish this variable in the help.
45511 45511
45512 45512
45513 45513 if [ -z "${BUILD_AR+x}" ]; then
45514 45514 # The variable is not set by user, try to locate tool using the code snippet
45515 45515 for ac_prog in ar gcc-ar
45516 45516 do
45517 45517 # Extract the first word of "$ac_prog", so it can be a program name with args.
45518 45518 set dummy $ac_prog; ac_word=$2
45519 45519 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45520 45520 $as_echo_n "checking for $ac_word... " >&6; }
45521 45521 if ${ac_cv_path_BUILD_AR+:} false; then :
45522 45522 $as_echo_n "(cached) " >&6
45523 45523 else
45524 45524 case $BUILD_AR in
45525 45525 [\\/]* | ?:[\\/]*)
45526 45526 ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
45527 45527 ;;
45528 45528 *)
45529 45529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45530 45530 for as_dir in $PATH
45531 45531 do
45532 45532 IFS=$as_save_IFS
45533 45533 test -z "$as_dir" && as_dir=.
45534 45534 for ac_exec_ext in '' $ac_executable_extensions; do
45535 45535 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45536 45536 ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
45537 45537 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45538 45538 break 2
45539 45539 fi
45540 45540 done
45541 45541 done
45542 45542 IFS=$as_save_IFS
45543 45543
45544 45544 ;;
45545 45545 esac
45546 45546 fi
45547 45547 BUILD_AR=$ac_cv_path_BUILD_AR
45548 45548 if test -n "$BUILD_AR"; then
45549 45549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
45550 45550 $as_echo "$BUILD_AR" >&6; }
45551 45551 else
45552 45552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45553 45553 $as_echo "no" >&6; }
45554 45554 fi
45555 45555
45556 45556
45557 45557 test -n "$BUILD_AR" && break
45558 45558 done
45559 45559
45560 45560 else
45561 45561 # The variable is set, but is it from the command line or the environment?
45562 45562
45563 45563 # Try to remove the string !BUILD_AR! from our list.
45564 45564 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_AR!/}
45565 45565 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
45566 45566 # If it failed, the variable was not from the command line. Ignore it,
45567 45567 # but warn the user (except for BASH, which is always set by the calling BASH).
45568 45568 if test "xBUILD_AR" != xBASH; then
45569 45569 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_AR from the environment. Use command line variables instead." >&5
45570 45570 $as_echo "$as_me: WARNING: Ignoring value of BUILD_AR from the environment. Use command line variables instead." >&2;}
45571 45571 fi
45572 45572 # Try to locate tool using the code snippet
45573 45573 for ac_prog in ar gcc-ar
45574 45574 do
45575 45575 # Extract the first word of "$ac_prog", so it can be a program name with args.
45576 45576 set dummy $ac_prog; ac_word=$2
45577 45577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45578 45578 $as_echo_n "checking for $ac_word... " >&6; }
45579 45579 if ${ac_cv_path_BUILD_AR+:} false; then :
45580 45580 $as_echo_n "(cached) " >&6
45581 45581 else
45582 45582 case $BUILD_AR in
45583 45583 [\\/]* | ?:[\\/]*)
45584 45584 ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
45585 45585 ;;
45586 45586 *)
45587 45587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45588 45588 for as_dir in $PATH
45589 45589 do
45590 45590 IFS=$as_save_IFS
45591 45591 test -z "$as_dir" && as_dir=.
45592 45592 for ac_exec_ext in '' $ac_executable_extensions; do
45593 45593 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45594 45594 ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
45595 45595 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45596 45596 break 2
45597 45597 fi
45598 45598 done
45599 45599 done
45600 45600 IFS=$as_save_IFS
45601 45601
45602 45602 ;;
45603 45603 esac
45604 45604 fi
45605 45605 BUILD_AR=$ac_cv_path_BUILD_AR
45606 45606 if test -n "$BUILD_AR"; then
45607 45607 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
45608 45608 $as_echo "$BUILD_AR" >&6; }
45609 45609 else
45610 45610 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45611 45611 $as_echo "no" >&6; }
45612 45612 fi
45613 45613
45614 45614
45615 45615 test -n "$BUILD_AR" && break
45616 45616 done
45617 45617
45618 45618 else
45619 45619 # If it succeeded, then it was overridden by the user. We will use it
45620 45620 # for the tool.
45621 45621
45622 45622 # First remove it from the list of overridden variables, so we can test
45623 45623 # for unknown variables in the end.
45624 45624 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
45625 45625
45626 45626 # Check if we try to supply an empty value
45627 45627 if test "x$BUILD_AR" = x; then
45628 45628 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_AR= (no value)" >&5
45629 45629 $as_echo "$as_me: Setting user supplied tool BUILD_AR= (no value)" >&6;}
45630 45630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_AR" >&5
45631 45631 $as_echo_n "checking for BUILD_AR... " >&6; }
45632 45632 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
45633 45633 $as_echo "disabled" >&6; }
45634 45634 else
45635 45635 # Check if the provided tool contains a complete path.
45636 45636 tool_specified="$BUILD_AR"
45637 45637 tool_basename="${tool_specified##*/}"
45638 45638 if test "x$tool_basename" = "x$tool_specified"; then
45639 45639 # A command without a complete path is provided, search $PATH.
45640 45640 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_AR=$tool_basename" >&5
45641 45641 $as_echo "$as_me: Will search for user supplied tool BUILD_AR=$tool_basename" >&6;}
45642 45642 # Extract the first word of "$tool_basename", so it can be a program name with args.
45643 45643 set dummy $tool_basename; ac_word=$2
45644 45644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
45645 45645 $as_echo_n "checking for $ac_word... " >&6; }
45646 45646 if ${ac_cv_path_BUILD_AR+:} false; then :
45647 45647 $as_echo_n "(cached) " >&6
45648 45648 else
45649 45649 case $BUILD_AR in
45650 45650 [\\/]* | ?:[\\/]*)
45651 45651 ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
45652 45652 ;;
45653 45653 *)
45654 45654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
45655 45655 for as_dir in $PATH
45656 45656 do
45657 45657 IFS=$as_save_IFS
45658 45658 test -z "$as_dir" && as_dir=.
45659 45659 for ac_exec_ext in '' $ac_executable_extensions; do
45660 45660 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
45661 45661 ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
45662 45662 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
45663 45663 break 2
45664 45664 fi
45665 45665 done
45666 45666 done
45667 45667 IFS=$as_save_IFS
45668 45668
45669 45669 ;;
45670 45670 esac
45671 45671 fi
45672 45672 BUILD_AR=$ac_cv_path_BUILD_AR
45673 45673 if test -n "$BUILD_AR"; then
45674 45674 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
45675 45675 $as_echo "$BUILD_AR" >&6; }
45676 45676 else
45677 45677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
45678 45678 $as_echo "no" >&6; }
45679 45679 fi
45680 45680
45681 45681
45682 45682 if test "x$BUILD_AR" = x; then
45683 45683 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
45684 45684 fi
45685 45685 else
45686 45686 # Otherwise we believe it is a complete path. Use it as it is.
45687 45687 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_AR=$tool_specified" >&5
45688 45688 $as_echo "$as_me: Will use user supplied tool BUILD_AR=$tool_specified" >&6;}
45689 45689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_AR" >&5
45690 45690 $as_echo_n "checking for BUILD_AR... " >&6; }
45691 45691 if test ! -x "$tool_specified"; then
45692 45692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
45693 45693 $as_echo "not found" >&6; }
45694 45694 as_fn_error $? "User supplied tool BUILD_AR=$tool_specified does not exist or is not executable" "$LINENO" 5
45695 45695 fi
45696 45696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
45697 45697 $as_echo "$tool_specified" >&6; }
45698 45698 fi
45699 45699 fi
45700 45700 fi
45701 45701
45702 45702 fi
45703 45703
45704 45704
45705 45705
45706 45706 # Only process if variable expands to non-empty
45707 45707
45708 45708 if test "x$BUILD_AR" != x; then
45709 45709 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45710 45710
45711 45711 # First separate the path from the arguments. This will split at the first
45712 45712 # space.
45713 45713 complete="$BUILD_AR"
45714 45714 path="${complete%% *}"
45715 45715 tmp="$complete EOL"
45716 45716 arguments="${tmp#* }"
45717 45717
45718 45718 # Input might be given as Windows format, start by converting to
45719 45719 # unix format.
45720 45720 new_path=`$CYGPATH -u "$path"`
45721 45721
45722 45722 # Now try to locate executable using which
45723 45723 new_path=`$WHICH "$new_path" 2> /dev/null`
45724 45724 # bat and cmd files are not always considered executable in cygwin causing which
45725 45725 # to not find them
45726 45726 if test "x$new_path" = x \
45727 45727 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45728 45728 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45729 45729 new_path=`$CYGPATH -u "$path"`
45730 45730 fi
45731 45731 if test "x$new_path" = x; then
45732 45732 # Oops. Which didn't find the executable.
45733 45733 # The splitting of arguments from the executable at a space might have been incorrect,
45734 45734 # since paths with space are more likely in Windows. Give it another try with the whole
45735 45735 # argument.
45736 45736 path="$complete"
45737 45737 arguments="EOL"
45738 45738 new_path=`$CYGPATH -u "$path"`
45739 45739 new_path=`$WHICH "$new_path" 2> /dev/null`
45740 45740 # bat and cmd files are not always considered executable in cygwin causing which
45741 45741 # to not find them
45742 45742 if test "x$new_path" = x \
45743 45743 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45744 45744 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45745 45745 new_path=`$CYGPATH -u "$path"`
45746 45746 fi
45747 45747 if test "x$new_path" = x; then
45748 45748 # It's still not found. Now this is an unrecoverable error.
45749 45749 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
45750 45750 $as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
45751 45751 has_space=`$ECHO "$complete" | $GREP " "`
45752 45752 if test "x$has_space" != x; then
45753 45753 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
45754 45754 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
45755 45755 fi
45756 45756 as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
45757 45757 fi
45758 45758 fi
45759 45759
45760 45760 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
45761 45761 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
45762 45762 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
45763 45763 # "foo.exe" is OK but "foo" is an error.
45764 45764 #
45765 45765 # This test is therefore slightly more accurate than "test -f" to check for file presence.
45766 45766 # It is also a way to make sure we got the proper file name for the real test later on.
45767 45767 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
45768 45768 if test "x$test_shortpath" = x; then
45769 45769 # Short path failed, file does not exist as specified.
45770 45770 # Try adding .exe or .cmd
45771 45771 if test -f "${new_path}.exe"; then
45772 45772 input_to_shortpath="${new_path}.exe"
45773 45773 elif test -f "${new_path}.cmd"; then
45774 45774 input_to_shortpath="${new_path}.cmd"
45775 45775 else
45776 45776 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$new_path\", is invalid." >&5
45777 45777 $as_echo "$as_me: The path of BUILD_AR, which resolves as \"$new_path\", is invalid." >&6;}
45778 45778 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
45779 45779 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
45780 45780 as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
45781 45781 fi
45782 45782 else
45783 45783 input_to_shortpath="$new_path"
45784 45784 fi
45785 45785
45786 45786 # Call helper function which possibly converts this using DOS-style short mode.
45787 45787 # If so, the updated path is stored in $new_path.
45788 45788 new_path="$input_to_shortpath"
45789 45789
45790 45790 input_path="$input_to_shortpath"
45791 45791 # Check if we need to convert this using DOS-style short mode. If the path
45792 45792 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45793 45793 # take no chances and rewrite it.
45794 45794 # Note: m4 eats our [], so we need to use [ and ] instead.
45795 45795 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45796 45796 if test "x$has_forbidden_chars" != x; then
45797 45797 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45798 45798 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45799 45799 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45800 45800 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45801 45801 # Going to short mode and back again did indeed matter. Since short mode is
45802 45802 # case insensitive, let's make it lowercase to improve readability.
45803 45803 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45804 45804 # Now convert it back to Unix-style (cygpath)
45805 45805 input_path=`$CYGPATH -u "$shortmode_path"`
45806 45806 new_path="$input_path"
45807 45807 fi
45808 45808 fi
45809 45809
45810 45810 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45811 45811 if test "x$test_cygdrive_prefix" = x; then
45812 45812 # As a simple fix, exclude /usr/bin since it's not a real path.
45813 45813 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
45814 45814 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45815 45815 # a path prefixed by /cygdrive for fixpath to work.
45816 45816 new_path="$CYGWIN_ROOT_PATH$input_path"
45817 45817 fi
45818 45818 fi
45819 45819
45820 45820 # remove trailing .exe if any
45821 45821 new_path="${new_path/%.exe/}"
45822 45822
45823 45823 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45824 45824
45825 45825 # First separate the path from the arguments. This will split at the first
45826 45826 # space.
45827 45827 complete="$BUILD_AR"
45828 45828 path="${complete%% *}"
45829 45829 tmp="$complete EOL"
45830 45830 arguments="${tmp#* }"
45831 45831
45832 45832 # Input might be given as Windows format, start by converting to
45833 45833 # unix format.
45834 45834 new_path="$path"
45835 45835
45836 45836 windows_path="$new_path"
45837 45837 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45838 45838 unix_path=`$CYGPATH -u "$windows_path"`
45839 45839 new_path="$unix_path"
45840 45840 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45841 45841 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45842 45842 new_path="$unix_path"
45843 45843 fi
45844 45844
45845 45845
45846 45846 # Now try to locate executable using which
45847 45847 new_path=`$WHICH "$new_path" 2> /dev/null`
45848 45848
45849 45849 if test "x$new_path" = x; then
45850 45850 # Oops. Which didn't find the executable.
45851 45851 # The splitting of arguments from the executable at a space might have been incorrect,
45852 45852 # since paths with space are more likely in Windows. Give it another try with the whole
45853 45853 # argument.
45854 45854 path="$complete"
45855 45855 arguments="EOL"
45856 45856 new_path="$path"
45857 45857
45858 45858 windows_path="$new_path"
45859 45859 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45860 45860 unix_path=`$CYGPATH -u "$windows_path"`
45861 45861 new_path="$unix_path"
45862 45862 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45863 45863 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45864 45864 new_path="$unix_path"
45865 45865 fi
45866 45866
45867 45867
45868 45868 new_path=`$WHICH "$new_path" 2> /dev/null`
45869 45869 # bat and cmd files are not always considered executable in MSYS causing which
45870 45870 # to not find them
45871 45871 if test "x$new_path" = x \
45872 45872 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
45873 45873 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
45874 45874 new_path="$path"
45875 45875
45876 45876 windows_path="$new_path"
45877 45877 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45878 45878 unix_path=`$CYGPATH -u "$windows_path"`
45879 45879 new_path="$unix_path"
45880 45880 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45881 45881 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45882 45882 new_path="$unix_path"
45883 45883 fi
45884 45884
45885 45885 fi
45886 45886
45887 45887 if test "x$new_path" = x; then
45888 45888 # It's still not found. Now this is an unrecoverable error.
45889 45889 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
45890 45890 $as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
45891 45891 has_space=`$ECHO "$complete" | $GREP " "`
45892 45892 if test "x$has_space" != x; then
45893 45893 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
45894 45894 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
45895 45895 fi
45896 45896 as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
45897 45897 fi
45898 45898 fi
45899 45899
45900 45900 # Now new_path has a complete unix path to the binary
45901 45901 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
45902 45902 # Keep paths in /bin as-is, but remove trailing .exe if any
45903 45903 new_path="${new_path/%.exe/}"
45904 45904 # Do not save /bin paths to all_fixpath_prefixes!
45905 45905 else
45906 45906 # Not in mixed or Windows style, start by that.
45907 45907 new_path=`cmd //c echo $new_path`
45908 45908
45909 45909 input_path="$new_path"
45910 45910 # Check if we need to convert this using DOS-style short mode. If the path
45911 45911 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45912 45912 # take no chances and rewrite it.
45913 45913 # Note: m4 eats our [], so we need to use [ and ] instead.
45914 45914 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
45915 45915 if test "x$has_forbidden_chars" != x; then
45916 45916 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45917 45917 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45918 45918 fi
45919 45919
45920 45920 # Output is in $new_path
45921 45921
45922 45922 windows_path="$new_path"
45923 45923 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45924 45924 unix_path=`$CYGPATH -u "$windows_path"`
45925 45925 new_path="$unix_path"
45926 45926 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45927 45927 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45928 45928 new_path="$unix_path"
45929 45929 fi
45930 45930
45931 45931 # remove trailing .exe if any
45932 45932 new_path="${new_path/%.exe/}"
45933 45933
45934 45934 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45935 45935 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45936 45936 fi
45937 45937
45938 45938 else
45939 45939 # We're on a unix platform. Hooray! :)
45940 45940 # First separate the path from the arguments. This will split at the first
45941 45941 # space.
45942 45942 complete="$BUILD_AR"
45943 45943 path="${complete%% *}"
45944 45944 tmp="$complete EOL"
45945 45945 arguments="${tmp#* }"
45946 45946
45947 45947 # Cannot rely on the command "which" here since it doesn't always work.
45948 45948 is_absolute_path=`$ECHO "$path" | $GREP ^/`
45949 45949 if test -z "$is_absolute_path"; then
45950 45950 # Path to executable is not absolute. Find it.
45951 45951 IFS_save="$IFS"
45952 45952 IFS=:
45953 45953 for p in $PATH; do
45954 45954 if test -f "$p/$path" && test -x "$p/$path"; then
45955 45955 new_path="$p/$path"
45956 45956 break
45957 45957 fi
45958 45958 done
45959 45959 IFS="$IFS_save"
45960 45960 else
45961 45961 # This is an absolute path, we can use it without further modifications.
45962 45962 new_path="$path"
45963 45963 fi
45964 45964
45965 45965 if test "x$new_path" = x; then
45966 45966 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
45967 45967 $as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
45968 45968 has_space=`$ECHO "$complete" | $GREP " "`
45969 45969 if test "x$has_space" != x; then
45970 45970 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
45971 45971 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
45972 45972 fi
45973 45973 as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
45974 45974 fi
45975 45975 fi
45976 45976
45977 45977 # Now join together the path and the arguments once again
45978 45978 if test "x$arguments" != xEOL; then
45979 45979 new_complete="$new_path ${arguments% *}"
45980 45980 else
45981 45981 new_complete="$new_path"
45982 45982 fi
45983 45983
45984 45984 if test "x$complete" != "x$new_complete"; then
45985 45985 BUILD_AR="$new_complete"
45986 45986 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_AR to \"$new_complete\"" >&5
45987 45987 $as_echo "$as_me: Rewriting BUILD_AR to \"$new_complete\"" >&6;}
45988 45988 fi
45989 45989 fi
45990 45990
45991 45991
45992 45992
45993 45993 # Publish this variable in the help.
45994 45994
45995 45995
45996 45996 if [ -z "${BUILD_OBJCOPY+x}" ]; then
45997 45997 # The variable is not set by user, try to locate tool using the code snippet
45998 45998 for ac_prog in objcopy
45999 45999 do
46000 46000 # Extract the first word of "$ac_prog", so it can be a program name with args.
46001 46001 set dummy $ac_prog; ac_word=$2
46002 46002 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46003 46003 $as_echo_n "checking for $ac_word... " >&6; }
46004 46004 if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
46005 46005 $as_echo_n "(cached) " >&6
46006 46006 else
46007 46007 case $BUILD_OBJCOPY in
46008 46008 [\\/]* | ?:[\\/]*)
46009 46009 ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
46010 46010 ;;
46011 46011 *)
46012 46012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46013 46013 for as_dir in $PATH
46014 46014 do
46015 46015 IFS=$as_save_IFS
46016 46016 test -z "$as_dir" && as_dir=.
46017 46017 for ac_exec_ext in '' $ac_executable_extensions; do
46018 46018 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46019 46019 ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
46020 46020 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46021 46021 break 2
46022 46022 fi
46023 46023 done
46024 46024 done
46025 46025 IFS=$as_save_IFS
46026 46026
46027 46027 ;;
46028 46028 esac
46029 46029 fi
46030 46030 BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
46031 46031 if test -n "$BUILD_OBJCOPY"; then
46032 46032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
46033 46033 $as_echo "$BUILD_OBJCOPY" >&6; }
46034 46034 else
46035 46035 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46036 46036 $as_echo "no" >&6; }
46037 46037 fi
46038 46038
46039 46039
46040 46040 test -n "$BUILD_OBJCOPY" && break
46041 46041 done
46042 46042
46043 46043 else
46044 46044 # The variable is set, but is it from the command line or the environment?
46045 46045
46046 46046 # Try to remove the string !BUILD_OBJCOPY! from our list.
46047 46047 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_OBJCOPY!/}
46048 46048 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
46049 46049 # If it failed, the variable was not from the command line. Ignore it,
46050 46050 # but warn the user (except for BASH, which is always set by the calling BASH).
46051 46051 if test "xBUILD_OBJCOPY" != xBASH; then
46052 46052 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_OBJCOPY from the environment. Use command line variables instead." >&5
46053 46053 $as_echo "$as_me: WARNING: Ignoring value of BUILD_OBJCOPY from the environment. Use command line variables instead." >&2;}
46054 46054 fi
46055 46055 # Try to locate tool using the code snippet
46056 46056 for ac_prog in objcopy
46057 46057 do
46058 46058 # Extract the first word of "$ac_prog", so it can be a program name with args.
46059 46059 set dummy $ac_prog; ac_word=$2
46060 46060 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46061 46061 $as_echo_n "checking for $ac_word... " >&6; }
46062 46062 if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
46063 46063 $as_echo_n "(cached) " >&6
46064 46064 else
46065 46065 case $BUILD_OBJCOPY in
46066 46066 [\\/]* | ?:[\\/]*)
46067 46067 ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
46068 46068 ;;
46069 46069 *)
46070 46070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46071 46071 for as_dir in $PATH
46072 46072 do
46073 46073 IFS=$as_save_IFS
46074 46074 test -z "$as_dir" && as_dir=.
46075 46075 for ac_exec_ext in '' $ac_executable_extensions; do
46076 46076 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46077 46077 ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
46078 46078 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46079 46079 break 2
46080 46080 fi
46081 46081 done
46082 46082 done
46083 46083 IFS=$as_save_IFS
46084 46084
46085 46085 ;;
46086 46086 esac
46087 46087 fi
46088 46088 BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
46089 46089 if test -n "$BUILD_OBJCOPY"; then
46090 46090 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
46091 46091 $as_echo "$BUILD_OBJCOPY" >&6; }
46092 46092 else
46093 46093 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46094 46094 $as_echo "no" >&6; }
46095 46095 fi
46096 46096
46097 46097
46098 46098 test -n "$BUILD_OBJCOPY" && break
46099 46099 done
46100 46100
46101 46101 else
46102 46102 # If it succeeded, then it was overridden by the user. We will use it
46103 46103 # for the tool.
46104 46104
46105 46105 # First remove it from the list of overridden variables, so we can test
46106 46106 # for unknown variables in the end.
46107 46107 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
46108 46108
46109 46109 # Check if we try to supply an empty value
46110 46110 if test "x$BUILD_OBJCOPY" = x; then
46111 46111 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_OBJCOPY= (no value)" >&5
46112 46112 $as_echo "$as_me: Setting user supplied tool BUILD_OBJCOPY= (no value)" >&6;}
46113 46113 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_OBJCOPY" >&5
46114 46114 $as_echo_n "checking for BUILD_OBJCOPY... " >&6; }
46115 46115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
46116 46116 $as_echo "disabled" >&6; }
46117 46117 else
46118 46118 # Check if the provided tool contains a complete path.
46119 46119 tool_specified="$BUILD_OBJCOPY"
46120 46120 tool_basename="${tool_specified##*/}"
46121 46121 if test "x$tool_basename" = "x$tool_specified"; then
46122 46122 # A command without a complete path is provided, search $PATH.
46123 46123 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_OBJCOPY=$tool_basename" >&5
46124 46124 $as_echo "$as_me: Will search for user supplied tool BUILD_OBJCOPY=$tool_basename" >&6;}
46125 46125 # Extract the first word of "$tool_basename", so it can be a program name with args.
46126 46126 set dummy $tool_basename; ac_word=$2
46127 46127 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46128 46128 $as_echo_n "checking for $ac_word... " >&6; }
46129 46129 if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
46130 46130 $as_echo_n "(cached) " >&6
46131 46131 else
46132 46132 case $BUILD_OBJCOPY in
46133 46133 [\\/]* | ?:[\\/]*)
46134 46134 ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
46135 46135 ;;
46136 46136 *)
46137 46137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46138 46138 for as_dir in $PATH
46139 46139 do
46140 46140 IFS=$as_save_IFS
46141 46141 test -z "$as_dir" && as_dir=.
46142 46142 for ac_exec_ext in '' $ac_executable_extensions; do
46143 46143 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46144 46144 ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
46145 46145 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46146 46146 break 2
46147 46147 fi
46148 46148 done
46149 46149 done
46150 46150 IFS=$as_save_IFS
46151 46151
46152 46152 ;;
46153 46153 esac
46154 46154 fi
46155 46155 BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
46156 46156 if test -n "$BUILD_OBJCOPY"; then
46157 46157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
46158 46158 $as_echo "$BUILD_OBJCOPY" >&6; }
46159 46159 else
46160 46160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46161 46161 $as_echo "no" >&6; }
46162 46162 fi
46163 46163
46164 46164
46165 46165 if test "x$BUILD_OBJCOPY" = x; then
46166 46166 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
46167 46167 fi
46168 46168 else
46169 46169 # Otherwise we believe it is a complete path. Use it as it is.
46170 46170 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_OBJCOPY=$tool_specified" >&5
46171 46171 $as_echo "$as_me: Will use user supplied tool BUILD_OBJCOPY=$tool_specified" >&6;}
46172 46172 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_OBJCOPY" >&5
46173 46173 $as_echo_n "checking for BUILD_OBJCOPY... " >&6; }
46174 46174 if test ! -x "$tool_specified"; then
46175 46175 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
46176 46176 $as_echo "not found" >&6; }
46177 46177 as_fn_error $? "User supplied tool BUILD_OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
46178 46178 fi
46179 46179 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
46180 46180 $as_echo "$tool_specified" >&6; }
46181 46181 fi
46182 46182 fi
46183 46183 fi
46184 46184
46185 46185 fi
46186 46186
46187 46187
46188 46188
46189 46189 # Only process if variable expands to non-empty
46190 46190
46191 46191 if test "x$BUILD_OBJCOPY" != x; then
46192 46192 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46193 46193
46194 46194 # First separate the path from the arguments. This will split at the first
46195 46195 # space.
46196 46196 complete="$BUILD_OBJCOPY"
46197 46197 path="${complete%% *}"
46198 46198 tmp="$complete EOL"
46199 46199 arguments="${tmp#* }"
46200 46200
46201 46201 # Input might be given as Windows format, start by converting to
46202 46202 # unix format.
46203 46203 new_path=`$CYGPATH -u "$path"`
46204 46204
46205 46205 # Now try to locate executable using which
46206 46206 new_path=`$WHICH "$new_path" 2> /dev/null`
46207 46207 # bat and cmd files are not always considered executable in cygwin causing which
46208 46208 # to not find them
46209 46209 if test "x$new_path" = x \
46210 46210 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46211 46211 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46212 46212 new_path=`$CYGPATH -u "$path"`
46213 46213 fi
46214 46214 if test "x$new_path" = x; then
46215 46215 # Oops. Which didn't find the executable.
46216 46216 # The splitting of arguments from the executable at a space might have been incorrect,
46217 46217 # since paths with space are more likely in Windows. Give it another try with the whole
46218 46218 # argument.
46219 46219 path="$complete"
46220 46220 arguments="EOL"
46221 46221 new_path=`$CYGPATH -u "$path"`
46222 46222 new_path=`$WHICH "$new_path" 2> /dev/null`
46223 46223 # bat and cmd files are not always considered executable in cygwin causing which
46224 46224 # to not find them
46225 46225 if test "x$new_path" = x \
46226 46226 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46227 46227 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46228 46228 new_path=`$CYGPATH -u "$path"`
46229 46229 fi
46230 46230 if test "x$new_path" = x; then
46231 46231 # It's still not found. Now this is an unrecoverable error.
46232 46232 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
46233 46233 $as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
46234 46234 has_space=`$ECHO "$complete" | $GREP " "`
46235 46235 if test "x$has_space" != x; then
46236 46236 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
46237 46237 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
46238 46238 fi
46239 46239 as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
46240 46240 fi
46241 46241 fi
46242 46242
46243 46243 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
46244 46244 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
46245 46245 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
46246 46246 # "foo.exe" is OK but "foo" is an error.
46247 46247 #
46248 46248 # This test is therefore slightly more accurate than "test -f" to check for file presence.
46249 46249 # It is also a way to make sure we got the proper file name for the real test later on.
46250 46250 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
46251 46251 if test "x$test_shortpath" = x; then
46252 46252 # Short path failed, file does not exist as specified.
46253 46253 # Try adding .exe or .cmd
46254 46254 if test -f "${new_path}.exe"; then
46255 46255 input_to_shortpath="${new_path}.exe"
46256 46256 elif test -f "${new_path}.cmd"; then
46257 46257 input_to_shortpath="${new_path}.cmd"
46258 46258 else
46259 46259 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
46260 46260 $as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
46261 46261 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
46262 46262 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
46263 46263 as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
46264 46264 fi
46265 46265 else
46266 46266 input_to_shortpath="$new_path"
46267 46267 fi
46268 46268
46269 46269 # Call helper function which possibly converts this using DOS-style short mode.
46270 46270 # If so, the updated path is stored in $new_path.
46271 46271 new_path="$input_to_shortpath"
46272 46272
46273 46273 input_path="$input_to_shortpath"
46274 46274 # Check if we need to convert this using DOS-style short mode. If the path
46275 46275 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46276 46276 # take no chances and rewrite it.
46277 46277 # Note: m4 eats our [], so we need to use [ and ] instead.
46278 46278 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46279 46279 if test "x$has_forbidden_chars" != x; then
46280 46280 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46281 46281 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46282 46282 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46283 46283 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46284 46284 # Going to short mode and back again did indeed matter. Since short mode is
46285 46285 # case insensitive, let's make it lowercase to improve readability.
46286 46286 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46287 46287 # Now convert it back to Unix-style (cygpath)
46288 46288 input_path=`$CYGPATH -u "$shortmode_path"`
46289 46289 new_path="$input_path"
46290 46290 fi
46291 46291 fi
46292 46292
46293 46293 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46294 46294 if test "x$test_cygdrive_prefix" = x; then
46295 46295 # As a simple fix, exclude /usr/bin since it's not a real path.
46296 46296 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
46297 46297 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46298 46298 # a path prefixed by /cygdrive for fixpath to work.
46299 46299 new_path="$CYGWIN_ROOT_PATH$input_path"
46300 46300 fi
46301 46301 fi
46302 46302
46303 46303 # remove trailing .exe if any
46304 46304 new_path="${new_path/%.exe/}"
46305 46305
46306 46306 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46307 46307
46308 46308 # First separate the path from the arguments. This will split at the first
46309 46309 # space.
46310 46310 complete="$BUILD_OBJCOPY"
46311 46311 path="${complete%% *}"
46312 46312 tmp="$complete EOL"
46313 46313 arguments="${tmp#* }"
46314 46314
46315 46315 # Input might be given as Windows format, start by converting to
46316 46316 # unix format.
46317 46317 new_path="$path"
46318 46318
46319 46319 windows_path="$new_path"
46320 46320 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46321 46321 unix_path=`$CYGPATH -u "$windows_path"`
46322 46322 new_path="$unix_path"
46323 46323 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46324 46324 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46325 46325 new_path="$unix_path"
46326 46326 fi
46327 46327
46328 46328
46329 46329 # Now try to locate executable using which
46330 46330 new_path=`$WHICH "$new_path" 2> /dev/null`
46331 46331
46332 46332 if test "x$new_path" = x; then
46333 46333 # Oops. Which didn't find the executable.
46334 46334 # The splitting of arguments from the executable at a space might have been incorrect,
46335 46335 # since paths with space are more likely in Windows. Give it another try with the whole
46336 46336 # argument.
46337 46337 path="$complete"
46338 46338 arguments="EOL"
46339 46339 new_path="$path"
46340 46340
46341 46341 windows_path="$new_path"
46342 46342 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46343 46343 unix_path=`$CYGPATH -u "$windows_path"`
46344 46344 new_path="$unix_path"
46345 46345 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46346 46346 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46347 46347 new_path="$unix_path"
46348 46348 fi
46349 46349
46350 46350
46351 46351 new_path=`$WHICH "$new_path" 2> /dev/null`
46352 46352 # bat and cmd files are not always considered executable in MSYS causing which
46353 46353 # to not find them
46354 46354 if test "x$new_path" = x \
46355 46355 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46356 46356 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46357 46357 new_path="$path"
46358 46358
46359 46359 windows_path="$new_path"
46360 46360 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46361 46361 unix_path=`$CYGPATH -u "$windows_path"`
46362 46362 new_path="$unix_path"
46363 46363 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46364 46364 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46365 46365 new_path="$unix_path"
46366 46366 fi
46367 46367
46368 46368 fi
46369 46369
46370 46370 if test "x$new_path" = x; then
46371 46371 # It's still not found. Now this is an unrecoverable error.
46372 46372 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
46373 46373 $as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
46374 46374 has_space=`$ECHO "$complete" | $GREP " "`
46375 46375 if test "x$has_space" != x; then
46376 46376 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
46377 46377 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
46378 46378 fi
46379 46379 as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
46380 46380 fi
46381 46381 fi
46382 46382
46383 46383 # Now new_path has a complete unix path to the binary
46384 46384 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
46385 46385 # Keep paths in /bin as-is, but remove trailing .exe if any
46386 46386 new_path="${new_path/%.exe/}"
46387 46387 # Do not save /bin paths to all_fixpath_prefixes!
46388 46388 else
46389 46389 # Not in mixed or Windows style, start by that.
46390 46390 new_path=`cmd //c echo $new_path`
46391 46391
46392 46392 input_path="$new_path"
46393 46393 # Check if we need to convert this using DOS-style short mode. If the path
46394 46394 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46395 46395 # take no chances and rewrite it.
46396 46396 # Note: m4 eats our [], so we need to use [ and ] instead.
46397 46397 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
46398 46398 if test "x$has_forbidden_chars" != x; then
46399 46399 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46400 46400 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46401 46401 fi
46402 46402
46403 46403 # Output is in $new_path
46404 46404
46405 46405 windows_path="$new_path"
46406 46406 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46407 46407 unix_path=`$CYGPATH -u "$windows_path"`
46408 46408 new_path="$unix_path"
46409 46409 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46410 46410 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46411 46411 new_path="$unix_path"
46412 46412 fi
46413 46413
46414 46414 # remove trailing .exe if any
46415 46415 new_path="${new_path/%.exe/}"
46416 46416
46417 46417 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46418 46418 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46419 46419 fi
46420 46420
46421 46421 else
46422 46422 # We're on a unix platform. Hooray! :)
46423 46423 # First separate the path from the arguments. This will split at the first
46424 46424 # space.
46425 46425 complete="$BUILD_OBJCOPY"
46426 46426 path="${complete%% *}"
46427 46427 tmp="$complete EOL"
46428 46428 arguments="${tmp#* }"
46429 46429
46430 46430 # Cannot rely on the command "which" here since it doesn't always work.
46431 46431 is_absolute_path=`$ECHO "$path" | $GREP ^/`
46432 46432 if test -z "$is_absolute_path"; then
46433 46433 # Path to executable is not absolute. Find it.
46434 46434 IFS_save="$IFS"
46435 46435 IFS=:
46436 46436 for p in $PATH; do
46437 46437 if test -f "$p/$path" && test -x "$p/$path"; then
46438 46438 new_path="$p/$path"
46439 46439 break
46440 46440 fi
46441 46441 done
46442 46442 IFS="$IFS_save"
46443 46443 else
46444 46444 # This is an absolute path, we can use it without further modifications.
46445 46445 new_path="$path"
46446 46446 fi
46447 46447
46448 46448 if test "x$new_path" = x; then
46449 46449 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
46450 46450 $as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
46451 46451 has_space=`$ECHO "$complete" | $GREP " "`
46452 46452 if test "x$has_space" != x; then
46453 46453 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
46454 46454 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
46455 46455 fi
46456 46456 as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
46457 46457 fi
46458 46458 fi
46459 46459
46460 46460 # Now join together the path and the arguments once again
46461 46461 if test "x$arguments" != xEOL; then
46462 46462 new_complete="$new_path ${arguments% *}"
46463 46463 else
46464 46464 new_complete="$new_path"
46465 46465 fi
46466 46466
46467 46467 if test "x$complete" != "x$new_complete"; then
46468 46468 BUILD_OBJCOPY="$new_complete"
46469 46469 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_OBJCOPY to \"$new_complete\"" >&5
46470 46470 $as_echo "$as_me: Rewriting BUILD_OBJCOPY to \"$new_complete\"" >&6;}
46471 46471 fi
46472 46472 fi
46473 46473
46474 46474
46475 46475
46476 46476 # Publish this variable in the help.
46477 46477
46478 46478
46479 46479 if [ -z "${BUILD_STRIP+x}" ]; then
46480 46480 # The variable is not set by user, try to locate tool using the code snippet
46481 46481 for ac_prog in strip
46482 46482 do
46483 46483 # Extract the first word of "$ac_prog", so it can be a program name with args.
46484 46484 set dummy $ac_prog; ac_word=$2
46485 46485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46486 46486 $as_echo_n "checking for $ac_word... " >&6; }
46487 46487 if ${ac_cv_path_BUILD_STRIP+:} false; then :
46488 46488 $as_echo_n "(cached) " >&6
46489 46489 else
46490 46490 case $BUILD_STRIP in
46491 46491 [\\/]* | ?:[\\/]*)
46492 46492 ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
46493 46493 ;;
46494 46494 *)
46495 46495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46496 46496 for as_dir in $PATH
46497 46497 do
46498 46498 IFS=$as_save_IFS
46499 46499 test -z "$as_dir" && as_dir=.
46500 46500 for ac_exec_ext in '' $ac_executable_extensions; do
46501 46501 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46502 46502 ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
46503 46503 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46504 46504 break 2
46505 46505 fi
46506 46506 done
46507 46507 done
46508 46508 IFS=$as_save_IFS
46509 46509
46510 46510 ;;
46511 46511 esac
46512 46512 fi
46513 46513 BUILD_STRIP=$ac_cv_path_BUILD_STRIP
46514 46514 if test -n "$BUILD_STRIP"; then
46515 46515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
46516 46516 $as_echo "$BUILD_STRIP" >&6; }
46517 46517 else
46518 46518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46519 46519 $as_echo "no" >&6; }
46520 46520 fi
46521 46521
46522 46522
46523 46523 test -n "$BUILD_STRIP" && break
46524 46524 done
46525 46525
46526 46526 else
46527 46527 # The variable is set, but is it from the command line or the environment?
46528 46528
46529 46529 # Try to remove the string !BUILD_STRIP! from our list.
46530 46530 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_STRIP!/}
46531 46531 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
46532 46532 # If it failed, the variable was not from the command line. Ignore it,
46533 46533 # but warn the user (except for BASH, which is always set by the calling BASH).
46534 46534 if test "xBUILD_STRIP" != xBASH; then
46535 46535 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_STRIP from the environment. Use command line variables instead." >&5
46536 46536 $as_echo "$as_me: WARNING: Ignoring value of BUILD_STRIP from the environment. Use command line variables instead." >&2;}
46537 46537 fi
46538 46538 # Try to locate tool using the code snippet
46539 46539 for ac_prog in strip
46540 46540 do
46541 46541 # Extract the first word of "$ac_prog", so it can be a program name with args.
46542 46542 set dummy $ac_prog; ac_word=$2
46543 46543 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46544 46544 $as_echo_n "checking for $ac_word... " >&6; }
46545 46545 if ${ac_cv_path_BUILD_STRIP+:} false; then :
46546 46546 $as_echo_n "(cached) " >&6
46547 46547 else
46548 46548 case $BUILD_STRIP in
46549 46549 [\\/]* | ?:[\\/]*)
46550 46550 ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
46551 46551 ;;
46552 46552 *)
46553 46553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46554 46554 for as_dir in $PATH
46555 46555 do
46556 46556 IFS=$as_save_IFS
46557 46557 test -z "$as_dir" && as_dir=.
46558 46558 for ac_exec_ext in '' $ac_executable_extensions; do
46559 46559 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46560 46560 ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
46561 46561 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46562 46562 break 2
46563 46563 fi
46564 46564 done
46565 46565 done
46566 46566 IFS=$as_save_IFS
46567 46567
46568 46568 ;;
46569 46569 esac
46570 46570 fi
46571 46571 BUILD_STRIP=$ac_cv_path_BUILD_STRIP
46572 46572 if test -n "$BUILD_STRIP"; then
46573 46573 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
46574 46574 $as_echo "$BUILD_STRIP" >&6; }
46575 46575 else
46576 46576 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46577 46577 $as_echo "no" >&6; }
46578 46578 fi
46579 46579
46580 46580
46581 46581 test -n "$BUILD_STRIP" && break
46582 46582 done
46583 46583
46584 46584 else
46585 46585 # If it succeeded, then it was overridden by the user. We will use it
46586 46586 # for the tool.
46587 46587
46588 46588 # First remove it from the list of overridden variables, so we can test
46589 46589 # for unknown variables in the end.
46590 46590 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
46591 46591
46592 46592 # Check if we try to supply an empty value
46593 46593 if test "x$BUILD_STRIP" = x; then
46594 46594 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_STRIP= (no value)" >&5
46595 46595 $as_echo "$as_me: Setting user supplied tool BUILD_STRIP= (no value)" >&6;}
46596 46596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_STRIP" >&5
46597 46597 $as_echo_n "checking for BUILD_STRIP... " >&6; }
46598 46598 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
46599 46599 $as_echo "disabled" >&6; }
46600 46600 else
46601 46601 # Check if the provided tool contains a complete path.
46602 46602 tool_specified="$BUILD_STRIP"
46603 46603 tool_basename="${tool_specified##*/}"
46604 46604 if test "x$tool_basename" = "x$tool_specified"; then
46605 46605 # A command without a complete path is provided, search $PATH.
46606 46606 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_STRIP=$tool_basename" >&5
46607 46607 $as_echo "$as_me: Will search for user supplied tool BUILD_STRIP=$tool_basename" >&6;}
46608 46608 # Extract the first word of "$tool_basename", so it can be a program name with args.
46609 46609 set dummy $tool_basename; ac_word=$2
46610 46610 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
46611 46611 $as_echo_n "checking for $ac_word... " >&6; }
46612 46612 if ${ac_cv_path_BUILD_STRIP+:} false; then :
46613 46613 $as_echo_n "(cached) " >&6
46614 46614 else
46615 46615 case $BUILD_STRIP in
46616 46616 [\\/]* | ?:[\\/]*)
46617 46617 ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
46618 46618 ;;
46619 46619 *)
46620 46620 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
46621 46621 for as_dir in $PATH
46622 46622 do
46623 46623 IFS=$as_save_IFS
46624 46624 test -z "$as_dir" && as_dir=.
46625 46625 for ac_exec_ext in '' $ac_executable_extensions; do
46626 46626 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
46627 46627 ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
46628 46628 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
46629 46629 break 2
46630 46630 fi
46631 46631 done
46632 46632 done
46633 46633 IFS=$as_save_IFS
46634 46634
46635 46635 ;;
46636 46636 esac
46637 46637 fi
46638 46638 BUILD_STRIP=$ac_cv_path_BUILD_STRIP
46639 46639 if test -n "$BUILD_STRIP"; then
46640 46640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
46641 46641 $as_echo "$BUILD_STRIP" >&6; }
46642 46642 else
46643 46643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
46644 46644 $as_echo "no" >&6; }
46645 46645 fi
46646 46646
46647 46647
46648 46648 if test "x$BUILD_STRIP" = x; then
46649 46649 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
46650 46650 fi
46651 46651 else
46652 46652 # Otherwise we believe it is a complete path. Use it as it is.
46653 46653 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_STRIP=$tool_specified" >&5
46654 46654 $as_echo "$as_me: Will use user supplied tool BUILD_STRIP=$tool_specified" >&6;}
46655 46655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_STRIP" >&5
46656 46656 $as_echo_n "checking for BUILD_STRIP... " >&6; }
46657 46657 if test ! -x "$tool_specified"; then
46658 46658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
46659 46659 $as_echo "not found" >&6; }
46660 46660 as_fn_error $? "User supplied tool BUILD_STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
46661 46661 fi
46662 46662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
46663 46663 $as_echo "$tool_specified" >&6; }
46664 46664 fi
46665 46665 fi
46666 46666 fi
46667 46667
46668 46668 fi
46669 46669
46670 46670
46671 46671
46672 46672 # Only process if variable expands to non-empty
46673 46673
46674 46674 if test "x$BUILD_STRIP" != x; then
46675 46675 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46676 46676
46677 46677 # First separate the path from the arguments. This will split at the first
46678 46678 # space.
46679 46679 complete="$BUILD_STRIP"
46680 46680 path="${complete%% *}"
46681 46681 tmp="$complete EOL"
46682 46682 arguments="${tmp#* }"
46683 46683
46684 46684 # Input might be given as Windows format, start by converting to
46685 46685 # unix format.
46686 46686 new_path=`$CYGPATH -u "$path"`
46687 46687
46688 46688 # Now try to locate executable using which
46689 46689 new_path=`$WHICH "$new_path" 2> /dev/null`
46690 46690 # bat and cmd files are not always considered executable in cygwin causing which
46691 46691 # to not find them
46692 46692 if test "x$new_path" = x \
46693 46693 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46694 46694 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46695 46695 new_path=`$CYGPATH -u "$path"`
46696 46696 fi
46697 46697 if test "x$new_path" = x; then
46698 46698 # Oops. Which didn't find the executable.
46699 46699 # The splitting of arguments from the executable at a space might have been incorrect,
46700 46700 # since paths with space are more likely in Windows. Give it another try with the whole
46701 46701 # argument.
46702 46702 path="$complete"
46703 46703 arguments="EOL"
46704 46704 new_path=`$CYGPATH -u "$path"`
46705 46705 new_path=`$WHICH "$new_path" 2> /dev/null`
46706 46706 # bat and cmd files are not always considered executable in cygwin causing which
46707 46707 # to not find them
46708 46708 if test "x$new_path" = x \
46709 46709 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46710 46710 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46711 46711 new_path=`$CYGPATH -u "$path"`
46712 46712 fi
46713 46713 if test "x$new_path" = x; then
46714 46714 # It's still not found. Now this is an unrecoverable error.
46715 46715 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
46716 46716 $as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
46717 46717 has_space=`$ECHO "$complete" | $GREP " "`
46718 46718 if test "x$has_space" != x; then
46719 46719 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
46720 46720 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
46721 46721 fi
46722 46722 as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
46723 46723 fi
46724 46724 fi
46725 46725
46726 46726 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
46727 46727 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
46728 46728 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
46729 46729 # "foo.exe" is OK but "foo" is an error.
46730 46730 #
46731 46731 # This test is therefore slightly more accurate than "test -f" to check for file presence.
46732 46732 # It is also a way to make sure we got the proper file name for the real test later on.
46733 46733 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
46734 46734 if test "x$test_shortpath" = x; then
46735 46735 # Short path failed, file does not exist as specified.
46736 46736 # Try adding .exe or .cmd
46737 46737 if test -f "${new_path}.exe"; then
46738 46738 input_to_shortpath="${new_path}.exe"
46739 46739 elif test -f "${new_path}.cmd"; then
46740 46740 input_to_shortpath="${new_path}.cmd"
46741 46741 else
46742 46742 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$new_path\", is invalid." >&5
46743 46743 $as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$new_path\", is invalid." >&6;}
46744 46744 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
46745 46745 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
46746 46746 as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
46747 46747 fi
46748 46748 else
46749 46749 input_to_shortpath="$new_path"
46750 46750 fi
46751 46751
46752 46752 # Call helper function which possibly converts this using DOS-style short mode.
46753 46753 # If so, the updated path is stored in $new_path.
46754 46754 new_path="$input_to_shortpath"
46755 46755
46756 46756 input_path="$input_to_shortpath"
46757 46757 # Check if we need to convert this using DOS-style short mode. If the path
46758 46758 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46759 46759 # take no chances and rewrite it.
46760 46760 # Note: m4 eats our [], so we need to use [ and ] instead.
46761 46761 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46762 46762 if test "x$has_forbidden_chars" != x; then
46763 46763 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46764 46764 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46765 46765 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46766 46766 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46767 46767 # Going to short mode and back again did indeed matter. Since short mode is
46768 46768 # case insensitive, let's make it lowercase to improve readability.
46769 46769 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46770 46770 # Now convert it back to Unix-style (cygpath)
46771 46771 input_path=`$CYGPATH -u "$shortmode_path"`
46772 46772 new_path="$input_path"
46773 46773 fi
46774 46774 fi
46775 46775
46776 46776 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46777 46777 if test "x$test_cygdrive_prefix" = x; then
46778 46778 # As a simple fix, exclude /usr/bin since it's not a real path.
46779 46779 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
46780 46780 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46781 46781 # a path prefixed by /cygdrive for fixpath to work.
46782 46782 new_path="$CYGWIN_ROOT_PATH$input_path"
46783 46783 fi
46784 46784 fi
46785 46785
46786 46786 # remove trailing .exe if any
46787 46787 new_path="${new_path/%.exe/}"
46788 46788
46789 46789 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46790 46790
46791 46791 # First separate the path from the arguments. This will split at the first
46792 46792 # space.
46793 46793 complete="$BUILD_STRIP"
46794 46794 path="${complete%% *}"
46795 46795 tmp="$complete EOL"
46796 46796 arguments="${tmp#* }"
46797 46797
46798 46798 # Input might be given as Windows format, start by converting to
46799 46799 # unix format.
46800 46800 new_path="$path"
46801 46801
46802 46802 windows_path="$new_path"
46803 46803 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46804 46804 unix_path=`$CYGPATH -u "$windows_path"`
46805 46805 new_path="$unix_path"
46806 46806 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46807 46807 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46808 46808 new_path="$unix_path"
46809 46809 fi
46810 46810
46811 46811
46812 46812 # Now try to locate executable using which
46813 46813 new_path=`$WHICH "$new_path" 2> /dev/null`
46814 46814
46815 46815 if test "x$new_path" = x; then
46816 46816 # Oops. Which didn't find the executable.
46817 46817 # The splitting of arguments from the executable at a space might have been incorrect,
46818 46818 # since paths with space are more likely in Windows. Give it another try with the whole
46819 46819 # argument.
46820 46820 path="$complete"
46821 46821 arguments="EOL"
46822 46822 new_path="$path"
46823 46823
46824 46824 windows_path="$new_path"
46825 46825 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46826 46826 unix_path=`$CYGPATH -u "$windows_path"`
46827 46827 new_path="$unix_path"
46828 46828 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46829 46829 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46830 46830 new_path="$unix_path"
46831 46831 fi
46832 46832
46833 46833
46834 46834 new_path=`$WHICH "$new_path" 2> /dev/null`
46835 46835 # bat and cmd files are not always considered executable in MSYS causing which
46836 46836 # to not find them
46837 46837 if test "x$new_path" = x \
46838 46838 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
46839 46839 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
46840 46840 new_path="$path"
46841 46841
46842 46842 windows_path="$new_path"
46843 46843 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46844 46844 unix_path=`$CYGPATH -u "$windows_path"`
46845 46845 new_path="$unix_path"
46846 46846 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46847 46847 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46848 46848 new_path="$unix_path"
46849 46849 fi
46850 46850
46851 46851 fi
46852 46852
46853 46853 if test "x$new_path" = x; then
46854 46854 # It's still not found. Now this is an unrecoverable error.
46855 46855 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
46856 46856 $as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
46857 46857 has_space=`$ECHO "$complete" | $GREP " "`
46858 46858 if test "x$has_space" != x; then
46859 46859 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
46860 46860 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
46861 46861 fi
46862 46862 as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
46863 46863 fi
46864 46864 fi
46865 46865
46866 46866 # Now new_path has a complete unix path to the binary
46867 46867 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
46868 46868 # Keep paths in /bin as-is, but remove trailing .exe if any
46869 46869 new_path="${new_path/%.exe/}"
46870 46870 # Do not save /bin paths to all_fixpath_prefixes!
46871 46871 else
46872 46872 # Not in mixed or Windows style, start by that.
46873 46873 new_path=`cmd //c echo $new_path`
46874 46874
46875 46875 input_path="$new_path"
46876 46876 # Check if we need to convert this using DOS-style short mode. If the path
46877 46877 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46878 46878 # take no chances and rewrite it.
46879 46879 # Note: m4 eats our [], so we need to use [ and ] instead.
46880 46880 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
46881 46881 if test "x$has_forbidden_chars" != x; then
46882 46882 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46883 46883 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46884 46884 fi
46885 46885
46886 46886 # Output is in $new_path
46887 46887
46888 46888 windows_path="$new_path"
46889 46889 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46890 46890 unix_path=`$CYGPATH -u "$windows_path"`
46891 46891 new_path="$unix_path"
46892 46892 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46893 46893 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46894 46894 new_path="$unix_path"
46895 46895 fi
46896 46896
46897 46897 # remove trailing .exe if any
46898 46898 new_path="${new_path/%.exe/}"
46899 46899
46900 46900 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46901 46901 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46902 46902 fi
46903 46903
46904 46904 else
46905 46905 # We're on a unix platform. Hooray! :)
46906 46906 # First separate the path from the arguments. This will split at the first
46907 46907 # space.
46908 46908 complete="$BUILD_STRIP"
46909 46909 path="${complete%% *}"
46910 46910 tmp="$complete EOL"
46911 46911 arguments="${tmp#* }"
46912 46912
46913 46913 # Cannot rely on the command "which" here since it doesn't always work.
46914 46914 is_absolute_path=`$ECHO "$path" | $GREP ^/`
46915 46915 if test -z "$is_absolute_path"; then
46916 46916 # Path to executable is not absolute. Find it.
46917 46917 IFS_save="$IFS"
46918 46918 IFS=:
46919 46919 for p in $PATH; do
46920 46920 if test -f "$p/$path" && test -x "$p/$path"; then
46921 46921 new_path="$p/$path"
46922 46922 break
46923 46923 fi
46924 46924 done
46925 46925 IFS="$IFS_save"
46926 46926 else
46927 46927 # This is an absolute path, we can use it without further modifications.
46928 46928 new_path="$path"
46929 46929 fi
46930 46930
46931 46931 if test "x$new_path" = x; then
46932 46932 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
46933 46933 $as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
46934 46934 has_space=`$ECHO "$complete" | $GREP " "`
46935 46935 if test "x$has_space" != x; then
46936 46936 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
46937 46937 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
46938 46938 fi
46939 46939 as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
46940 46940 fi
46941 46941 fi
46942 46942
46943 46943 # Now join together the path and the arguments once again
46944 46944 if test "x$arguments" != xEOL; then
46945 46945 new_complete="$new_path ${arguments% *}"
46946 46946 else
46947 46947 new_complete="$new_path"
46948 46948 fi
46949 46949
46950 46950 if test "x$complete" != "x$new_complete"; then
46951 46951 BUILD_STRIP="$new_complete"
46952 46952 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_STRIP to \"$new_complete\"" >&5
46953 46953 $as_echo "$as_me: Rewriting BUILD_STRIP to \"$new_complete\"" >&6;}
46954 46954 fi
46955 46955 fi
46956 46956
46957 46957 # Assume the C compiler is the assembler
46958 46958 BUILD_AS="$BUILD_CC -c"
46959 46959 # Just like for the target compiler, use the compiler as linker
46960 46960 BUILD_LD="$BUILD_CC"
46961 46961 BUILD_LDCXX="$BUILD_CXX"
46962 46962
46963 46963 PATH="$OLDPATH"
46964 46964
46965 46965
46966 46966 COMPILER=$BUILD_CC
46967 46967 COMPILER_NAME=BuildC
46968 46968
46969 46969 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
46970 46970 # cc -V output typically looks like
46971 46971 # cc: Sun C 5.12 Linux_i386 2011/11/16
46972 46972 COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
46973 46973 # Check that this is likely to be the Solaris Studio cc.
46974 46974 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
46975 46975 if test $? -ne 0; then
46976 46976 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
46977 46977 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
46978 46978 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
46979 46979 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
46980 46980 $as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
46981 46981 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
46982 46982 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
46983 46983 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
46984 46984 fi
46985 46985 # Remove usage instructions (if present), and
46986 46986 # collapse compiler output into a single line
46987 46987 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
46988 46988 $SED -e 's/ *[Uu]sage:.*//'`
46989 46989 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
46990 46990 $SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
46991 46991 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
46992 46992 # xlc -qversion output typically looks like
46993 46993 # IBM XL C/C++ for AIX, V11.1 (5724-X13)
46994 46994 # Version: 11.01.0000.0015
46995 46995 COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
46996 46996 # Check that this is likely to be the IBM XL C compiler.
46997 46997 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
46998 46998 if test $? -ne 0; then
46999 46999 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47000 47000 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47001 47001 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47002 47002 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47003 47003 $as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47004 47004 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
47005 47005 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
47006 47006 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47007 47007 fi
47008 47008 # Collapse compiler output into a single line
47009 47009 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47010 47010 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47011 47011 $SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
47012 47012 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
47013 47013 # There is no specific version flag, but all output starts with a version string.
47014 47014 # First line typically looks something like:
47015 47015 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
47016 47016 COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
47017 47017 # Check that this is likely to be Microsoft CL.EXE.
47018 47018 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
47019 47019 if test $? -ne 0; then
47020 47020 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47021 47021 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47022 47022 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47023 47023 $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47024 47024 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47025 47025 fi
47026 47026 # Collapse compiler output into a single line
47027 47027 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47028 47028 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47029 47029 $SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
47030 47030 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
47031 47031 # gcc --version output typically looks like
47032 47032 # gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
47033 47033 # Copyright (C) 2013 Free Software Foundation, Inc.
47034 47034 # This is free software; see the source for copying conditions. There is NO
47035 47035 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
47036 47036 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47037 47037 # Check that this is likely to be GCC.
47038 47038 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
47039 47039 if test $? -ne 0; then
47040 47040 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47041 47041 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47042 47042 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
47043 47043 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
47044 47044 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47045 47045 fi
47046 47046 # Remove Copyright and legalese from version string, and
47047 47047 # collapse into a single line
47048 47048 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
47049 47049 $SED -e 's/ *Copyright .*//'`
47050 47050 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47051 47051 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
47052 47052 elif test "x$TOOLCHAIN_TYPE" = xclang; then
47053 47053 # clang --version output typically looks like
47054 47054 # Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
47055 47055 # clang version 3.3 (tags/RELEASE_33/final)
47056 47056 # or
47057 47057 # Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
47058 47058 # Target: x86_64-pc-linux-gnu
47059 47059 # Thread model: posix
47060 47060 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47061 47061 # Check that this is likely to be clang
47062 47062 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
47063 47063 if test $? -ne 0; then
47064 47064 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47065 47065 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47066 47066 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47067 47067 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47068 47068 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47069 47069 fi
47070 47070 # Collapse compiler output into a single line
47071 47071 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47072 47072 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47073 47073 $SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
47074 47074 else
47075 47075 as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
47076 47076 fi
47077 47077 # This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
47078 47078 BUILD_CC_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
47079 47079 # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
47080 47080 BUILD_CC_VERSION_STRING="$COMPILER_VERSION_STRING"
47081 47081
47082 47082 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
47083 47083 $as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
47084 47084
47085 47085
47086 47086 COMPILER=$BUILD_CXX
47087 47087 COMPILER_NAME=BuildC++
47088 47088
47089 47089 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
47090 47090 # cc -V output typically looks like
47091 47091 # cc: Sun C 5.12 Linux_i386 2011/11/16
47092 47092 COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
47093 47093 # Check that this is likely to be the Solaris Studio cc.
47094 47094 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
47095 47095 if test $? -ne 0; then
47096 47096 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47097 47097 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47098 47098 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47099 47099 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47100 47100 $as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47101 47101 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
47102 47102 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
47103 47103 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47104 47104 fi
47105 47105 # Remove usage instructions (if present), and
47106 47106 # collapse compiler output into a single line
47107 47107 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
47108 47108 $SED -e 's/ *[Uu]sage:.*//'`
47109 47109 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47110 47110 $SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
47111 47111 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
47112 47112 # xlc -qversion output typically looks like
47113 47113 # IBM XL C/C++ for AIX, V11.1 (5724-X13)
47114 47114 # Version: 11.01.0000.0015
47115 47115 COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
47116 47116 # Check that this is likely to be the IBM XL C compiler.
47117 47117 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
47118 47118 if test $? -ne 0; then
47119 47119 ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47120 47120 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47121 47121 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47122 47122 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47123 47123 $as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47124 47124 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
47125 47125 $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
47126 47126 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47127 47127 fi
47128 47128 # Collapse compiler output into a single line
47129 47129 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47130 47130 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47131 47131 $SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
47132 47132 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
47133 47133 # There is no specific version flag, but all output starts with a version string.
47134 47134 # First line typically looks something like:
47135 47135 # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
47136 47136 COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
47137 47137 # Check that this is likely to be Microsoft CL.EXE.
47138 47138 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
47139 47139 if test $? -ne 0; then
47140 47140 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47141 47141 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47142 47142 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47143 47143 $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47144 47144 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47145 47145 fi
47146 47146 # Collapse compiler output into a single line
47147 47147 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47148 47148 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47149 47149 $SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
47150 47150 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
47151 47151 # gcc --version output typically looks like
47152 47152 # gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
47153 47153 # Copyright (C) 2013 Free Software Foundation, Inc.
47154 47154 # This is free software; see the source for copying conditions. There is NO
47155 47155 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
47156 47156 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47157 47157 # Check that this is likely to be GCC.
47158 47158 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
47159 47159 if test $? -ne 0; then
47160 47160 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47161 47161 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47162 47162 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
47163 47163 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
47164 47164 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47165 47165 fi
47166 47166 # Remove Copyright and legalese from version string, and
47167 47167 # collapse into a single line
47168 47168 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
47169 47169 $SED -e 's/ *Copyright .*//'`
47170 47170 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47171 47171 $SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
47172 47172 elif test "x$TOOLCHAIN_TYPE" = xclang; then
47173 47173 # clang --version output typically looks like
47174 47174 # Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
47175 47175 # clang version 3.3 (tags/RELEASE_33/final)
47176 47176 # or
47177 47177 # Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
47178 47178 # Target: x86_64-pc-linux-gnu
47179 47179 # Thread model: posix
47180 47180 COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
47181 47181 # Check that this is likely to be clang
47182 47182 $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
47183 47183 if test $? -ne 0; then
47184 47184 { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
47185 47185 $as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
47186 47186 { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
47187 47187 $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
47188 47188 as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
47189 47189 fi
47190 47190 # Collapse compiler output into a single line
47191 47191 COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
47192 47192 COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
47193 47193 $SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
47194 47194 else
47195 47195 as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
47196 47196 fi
47197 47197 # This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
47198 47198 BUILD_CXX_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
47199 47199 # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
47200 47200 BUILD_CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
47201 47201
47202 47202 { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
47203 47203 $as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
47204 47204
47205 47205
47206 47206 if test "x$BUILD_CC_VERSION_NUMBER" != "x$BUILD_CXX_VERSION_NUMBER"; then
47207 47207 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&5
47208 47208 $as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&2;}
47209 47209 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
47210 47210 $as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
47211 47211 fi
47212 47212
47213 47213 # We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
47214 47214 if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
47215 47215 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
47216 47216 $as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
47217 47217 fi
47218 47218
47219 47219 if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
47220 47220 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
47221 47221 $as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
47222 47222 fi
47223 47223
47224 47224 OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$BUILD_CC_VERSION_NUMBER"`
47225 47225
47226 47226 else
47227 47227 # If we are not cross compiling, use the normal target compilers for
47228 47228 # building the build platform executables.
47229 47229 BUILD_CC="$CC"
47230 47230 BUILD_CXX="$CXX"
47231 47231 BUILD_LD="$LD"
47232 47232 BUILD_LDCXX="$LDCXX"
47233 47233 BUILD_NM="$NM"
47234 47234 BUILD_AS="$AS"
47235 47235 BUILD_OBJCOPY="$OBJCOPY"
47236 47236 BUILD_STRIP="$STRIP"
47237 47237 BUILD_SYSROOT_CFLAGS="$SYSROOT_CFLAGS"
47238 47238 BUILD_SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS"
47239 47239 BUILD_AR="$AR"
47240 47240
47241 47241
47242 47242 if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
47243 47243 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
47244 47244 $as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
47245 47245 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
47246 47246 $as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
47247 47247 fi
47248 47248
47249 47249 # We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
47250 47250 if [[ "[$]CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
47251 47251 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
47252 47252 $as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
47253 47253 fi
47254 47254
47255 47255 if [[ "[$]CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
47256 47256 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
47257 47257 $as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
47258 47258 fi
47259 47259
47260 47260 OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$CC_VERSION_NUMBER"`
47261 47261
47262 47262 fi
47263 47263
47264 47264
47265 47265
47266 47266
47267 47267
47268 47268
47269 47269
47270 47270
47271 47271
47272 47272
47273 47273
47274 47274
47275 47275 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
47276 47276 # For hotspot, we need these in Windows mixed path,
47277 47277 # so rewrite them all. Need added .exe suffix.
47278 47278 HOTSPOT_CXX="$CXX.exe"
47279 47279 HOTSPOT_LD="$LD.exe"
47280 47280 HOTSPOT_MT="$MT.exe"
47281 47281 HOTSPOT_RC="$RC.exe"
47282 47282
47283 47283 unix_path="$HOTSPOT_CXX"
47284 47284 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47285 47285 windows_path=`$CYGPATH -m "$unix_path"`
47286 47286 HOTSPOT_CXX="$windows_path"
47287 47287 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47288 47288 windows_path=`cmd //c echo $unix_path`
47289 47289 HOTSPOT_CXX="$windows_path"
47290 47290 fi
47291 47291
47292 47292
47293 47293 unix_path="$HOTSPOT_LD"
47294 47294 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47295 47295 windows_path=`$CYGPATH -m "$unix_path"`
47296 47296 HOTSPOT_LD="$windows_path"
47297 47297 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47298 47298 windows_path=`cmd //c echo $unix_path`
47299 47299 HOTSPOT_LD="$windows_path"
47300 47300 fi
47301 47301
47302 47302
47303 47303 unix_path="$HOTSPOT_MT"
47304 47304 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47305 47305 windows_path=`$CYGPATH -m "$unix_path"`
47306 47306 HOTSPOT_MT="$windows_path"
47307 47307 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47308 47308 windows_path=`cmd //c echo $unix_path`
47309 47309 HOTSPOT_MT="$windows_path"
47310 47310 fi
47311 47311
47312 47312
47313 47313 unix_path="$HOTSPOT_RC"
47314 47314 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47315 47315 windows_path=`$CYGPATH -m "$unix_path"`
47316 47316 HOTSPOT_RC="$windows_path"
47317 47317 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47318 47318 windows_path=`cmd //c echo $unix_path`
47319 47319 HOTSPOT_RC="$windows_path"
47320 47320 fi
47321 47321
47322 47322
47323 47323
47324 47324 else
47325 47325 HOTSPOT_CXX="$CXX"
47326 47326 HOTSPOT_LD="$LD"
47327 47327 fi
47328 47328
47329 47329
47330 47330
47331 47331 if test "x$TOOLCHAIN_TYPE" = xclang; then
47332 47332 USE_CLANG=true
47333 47333 fi
47334 47334
47335 47335
47336 47336
47337 47337
47338 47338
47339 47339 # The package path is used only on macosx?
47340 47340 # FIXME: clean this up, and/or move it elsewhere.
47341 47341 PACKAGE_PATH=/opt/local
47342 47342
47343 47343
47344 47344 # Check for extra potential brokenness.
47345 47345 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
47346 47346 # On Windows, double-check that we got the right compiler.
47347 47347 CC_VERSION_OUTPUT=`$CC 2>&1 | $HEAD -n 1 | $TR -d '\r'`
47348 47348 COMPILER_CPU_TEST=`$ECHO $CC_VERSION_OUTPUT | $SED -n "s/^.* \(.*\)$/\1/p"`
47349 47349 if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
47350 47350 if test "x$COMPILER_CPU_TEST" != "x80x86" -a "x$COMPILER_CPU_TEST" != "xx86"; then
47351 47351 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"80x86\" or \"x86\"." "$LINENO" 5
47352 47352 fi
47353 47353 elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
47354 47354 if test "x$COMPILER_CPU_TEST" != "xx64"; then
47355 47355 as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
47356 47356 fi
47357 47357 fi
47358 47358 fi
47359 47359
47360 47360 if test "x$TOOLCHAIN_TYPE" = xgcc; then
47361 47361 # If this is a --hash-style=gnu system, use --hash-style=both, why?
47362 47362 HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
47363 47363 # This is later checked when setting flags.
47364 47364
47365 47365 # "-Og" suppported for GCC 4.8 and later
47366 47366 CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
47367 47367
47368 47368
47369 47369
47370 47370
47371 47371
47372 47372
47373 47373
47374 47374
47375 47375
47376 47376
47377 47377
47378 47378
47379 47379
47380 47380
47381 47381
47382 47382
47383 47383
47384 47384
47385 47385
47386 47386
47387 47387
47388 47388
47389 47389
47390 47390
47391 47391
47392 47392
47393 47393
47394 47394
47395 47395
47396 47396
47397 47397
47398 47398
47399 47399
47400 47400
47401 47401
47402 47402
47403 47403
47404 47404
47405 47405
47406 47406
47407 47407
47408 47408
47409 47409
47410 47410
47411 47411
47412 47412
47413 47413
47414 47414 # Execute function body
47415 47415
47416 47416
47417 47417
47418 47418
47419 47419
47420 47420
47421 47421
47422 47422
47423 47423
47424 47424
47425 47425
47426 47426
47427 47427
47428 47428
47429 47429
47430 47430
47431 47431
47432 47432
47433 47433
47434 47434
47435 47435
47436 47436
47437 47437
47438 47438
47439 47439
47440 47440
47441 47441
47442 47442
47443 47443
47444 47444
47445 47445
47446 47446
47447 47447
47448 47448
47449 47449
47450 47450
47451 47451
47452 47452
47453 47453
47454 47454
47455 47455
47456 47456
47457 47457
47458 47458
47459 47459
47460 47460
47461 47461
47462 47462
47463 47463 # Execute function body
47464 47464
47465 47465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
47466 47466 $as_echo_n "checking if the C compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
47467 47467 supports=yes
47468 47468
47469 47469 saved_cflags="$CFLAGS"
47470 47470 CFLAGS="$CFLAGS $CFLAG_OPTIMIZE_DEBUG_FLAG"
47471 47471 ac_ext=c
47472 47472 ac_cpp='$CPP $CPPFLAGS'
47473 47473 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47474 47474 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47475 47475 ac_compiler_gnu=$ac_cv_c_compiler_gnu
47476 47476
47477 47477 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
47478 47478 /* end confdefs.h. */
47479 47479 int i;
47480 47480 _ACEOF
47481 47481 if ac_fn_c_try_compile "$LINENO"; then :
47482 47482
47483 47483 else
47484 47484 supports=no
47485 47485 fi
47486 47486 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
47487 47487 ac_ext=cpp
47488 47488 ac_cpp='$CXXCPP $CPPFLAGS'
47489 47489 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47490 47490 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47491 47491 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
47492 47492
47493 47493 CFLAGS="$saved_cflags"
47494 47494
47495 47495 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
47496 47496 $as_echo "$supports" >&6; }
47497 47497 if test "x$supports" = "xyes" ; then
47498 47498 :
47499 47499 C_COMP_SUPPORTS="yes"
47500 47500 else
47501 47501 :
47502 47502 C_COMP_SUPPORTS="no"
47503 47503 fi
47504 47504
47505 47505
47506 47506
47507 47507
47508 47508
47509 47509
47510 47510
47511 47511
47512 47512
47513 47513
47514 47514
47515 47515
47516 47516
47517 47517
47518 47518
47519 47519
47520 47520
47521 47521
47522 47522
47523 47523
47524 47524
47525 47525
47526 47526
47527 47527
47528 47528
47529 47529
47530 47530
47531 47531
47532 47532
47533 47533
47534 47534
47535 47535
47536 47536
47537 47537
47538 47538
47539 47539
47540 47540
47541 47541
47542 47542
47543 47543
47544 47544
47545 47545
47546 47546
47547 47547
47548 47548
47549 47549
47550 47550
47551 47551
47552 47552
47553 47553
47554 47554
47555 47555
47556 47556
47557 47557
47558 47558
47559 47559
47560 47560
47561 47561
47562 47562
47563 47563 # Execute function body
47564 47564
47565 47565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
47566 47566 $as_echo_n "checking if the C++ compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
47567 47567 supports=yes
47568 47568
47569 47569 saved_cxxflags="$CXXFLAGS"
47570 47570 CXXFLAGS="$CXXFLAG $CFLAG_OPTIMIZE_DEBUG_FLAG"
47571 47571 ac_ext=cpp
47572 47572 ac_cpp='$CXXCPP $CPPFLAGS'
47573 47573 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47574 47574 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47575 47575 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
47576 47576
47577 47577 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
47578 47578 /* end confdefs.h. */
47579 47579 int i;
47580 47580 _ACEOF
47581 47581 if ac_fn_cxx_try_compile "$LINENO"; then :
47582 47582
47583 47583 else
47584 47584 supports=no
47585 47585 fi
47586 47586 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
47587 47587 ac_ext=cpp
47588 47588 ac_cpp='$CXXCPP $CPPFLAGS'
47589 47589 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47590 47590 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47591 47591 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
47592 47592
47593 47593 CXXFLAGS="$saved_cxxflags"
47594 47594
47595 47595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
47596 47596 $as_echo "$supports" >&6; }
47597 47597 if test "x$supports" = "xyes" ; then
47598 47598 :
47599 47599 CXX_COMP_SUPPORTS="yes"
47600 47600 else
47601 47601 :
47602 47602 CXX_COMP_SUPPORTS="no"
47603 47603 fi
47604 47604
47605 47605
47606 47606
47607 47607
47608 47608
47609 47609
47610 47610
47611 47611
47612 47612
47613 47613
47614 47614
47615 47615
47616 47616
47617 47617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
47618 47618 $as_echo_n "checking if both compilers support \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
47619 47619 supports=no
47620 47620 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
47621 47621
47622 47622 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
47623 47623 $as_echo "$supports" >&6; }
47624 47624 if test "x$supports" = "xyes" ; then
47625 47625 :
47626 47626 HAS_CFLAG_OPTIMIZE_DEBUG=true
47627 47627 else
47628 47628 :
47629 47629 HAS_CFLAG_OPTIMIZE_DEBUG=false
47630 47630 fi
47631 47631
47632 47632
47633 47633
47634 47634
47635 47635
47636 47636
47637 47637
47638 47638 # "-z relro" supported in GNU binutils 2.17 and later
47639 47639 LINKER_RELRO_FLAG="-Wl,-z,relro"
47640 47640
47641 47641
47642 47642
47643 47643
47644 47644
47645 47645
47646 47646
47647 47647
47648 47648
47649 47649
47650 47650
47651 47651
47652 47652
47653 47653
47654 47654
47655 47655
47656 47656
47657 47657
47658 47658
47659 47659
47660 47660
47661 47661
47662 47662
47663 47663
47664 47664
47665 47665
47666 47666
47667 47667
47668 47668
47669 47669
47670 47670
47671 47671
47672 47672
47673 47673
47674 47674
47675 47675
47676 47676
47677 47677
47678 47678
47679 47679
47680 47680
47681 47681
47682 47682
47683 47683
47684 47684
47685 47685
47686 47686
47687 47687 # Execute function body
47688 47688
47689 47689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_RELRO_FLAG\"" >&5
47690 47690 $as_echo_n "checking if linker supports \"$LINKER_RELRO_FLAG\"... " >&6; }
47691 47691 supports=yes
47692 47692
47693 47693 saved_ldflags="$LDFLAGS"
47694 47694 LDFLAGS="$LDFLAGS $LINKER_RELRO_FLAG"
47695 47695 ac_ext=c
47696 47696 ac_cpp='$CPP $CPPFLAGS'
47697 47697 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47698 47698 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47699 47699 ac_compiler_gnu=$ac_cv_c_compiler_gnu
47700 47700
47701 47701 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
47702 47702 /* end confdefs.h. */
47703 47703
47704 47704 int
47705 47705 main ()
47706 47706 {
47707 47707
47708 47708 ;
47709 47709 return 0;
47710 47710 }
47711 47711 _ACEOF
47712 47712 if ac_fn_c_try_link "$LINENO"; then :
47713 47713
47714 47714 else
47715 47715 supports=no
47716 47716 fi
47717 47717 rm -f core conftest.err conftest.$ac_objext \
47718 47718 conftest$ac_exeext conftest.$ac_ext
47719 47719 ac_ext=cpp
47720 47720 ac_cpp='$CXXCPP $CPPFLAGS'
47721 47721 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47722 47722 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47723 47723 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
47724 47724
47725 47725 LDFLAGS="$saved_ldflags"
47726 47726
47727 47727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
47728 47728 $as_echo "$supports" >&6; }
47729 47729 if test "x$supports" = "xyes" ; then
47730 47730 :
47731 47731 HAS_LINKER_RELRO=true
47732 47732 else
47733 47733 :
47734 47734 HAS_LINKER_RELRO=false
47735 47735 fi
47736 47736
47737 47737
47738 47738
47739 47739
47740 47740
47741 47741
47742 47742
47743 47743
47744 47744
47745 47745
47746 47746
47747 47747
47748 47748
47749 47749 # "-z now" supported in GNU binutils 2.11 and later
47750 47750 LINKER_NOW_FLAG="-Wl,-z,now"
47751 47751
47752 47752
47753 47753
47754 47754
47755 47755
47756 47756
47757 47757
47758 47758
47759 47759
47760 47760
47761 47761
47762 47762
47763 47763
47764 47764
47765 47765
47766 47766
47767 47767
47768 47768
47769 47769
47770 47770
47771 47771
47772 47772
47773 47773
47774 47774
47775 47775
47776 47776
47777 47777
47778 47778
47779 47779
47780 47780
47781 47781
47782 47782
47783 47783
47784 47784
47785 47785
47786 47786
47787 47787
47788 47788
47789 47789
47790 47790
47791 47791
47792 47792
47793 47793
47794 47794
47795 47795
47796 47796
47797 47797
47798 47798 # Execute function body
47799 47799
47800 47800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_NOW_FLAG\"" >&5
47801 47801 $as_echo_n "checking if linker supports \"$LINKER_NOW_FLAG\"... " >&6; }
47802 47802 supports=yes
47803 47803
47804 47804 saved_ldflags="$LDFLAGS"
47805 47805 LDFLAGS="$LDFLAGS $LINKER_NOW_FLAG"
47806 47806 ac_ext=c
47807 47807 ac_cpp='$CPP $CPPFLAGS'
47808 47808 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47809 47809 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47810 47810 ac_compiler_gnu=$ac_cv_c_compiler_gnu
47811 47811
47812 47812 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
47813 47813 /* end confdefs.h. */
47814 47814
47815 47815 int
47816 47816 main ()
47817 47817 {
47818 47818
47819 47819 ;
47820 47820 return 0;
47821 47821 }
47822 47822 _ACEOF
47823 47823 if ac_fn_c_try_link "$LINENO"; then :
47824 47824
47825 47825 else
47826 47826 supports=no
47827 47827 fi
47828 47828 rm -f core conftest.err conftest.$ac_objext \
47829 47829 conftest$ac_exeext conftest.$ac_ext
47830 47830 ac_ext=cpp
47831 47831 ac_cpp='$CXXCPP $CPPFLAGS'
47832 47832 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
47833 47833 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
47834 47834 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
47835 47835
47836 47836 LDFLAGS="$saved_ldflags"
47837 47837
47838 47838 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
47839 47839 $as_echo "$supports" >&6; }
47840 47840 if test "x$supports" = "xyes" ; then
47841 47841 :
47842 47842 HAS_LINKER_NOW=true
47843 47843 else
47844 47844 :
47845 47845 HAS_LINKER_NOW=false
47846 47846 fi
47847 47847
47848 47848
47849 47849
47850 47850
47851 47851
47852 47852
47853 47853
47854 47854
47855 47855
47856 47856
47857 47857
47858 47858
47859 47859 fi
47860 47860
47861 47861 # Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
47862 47862 # in executable.'
47863 47863 USING_BROKEN_SUSE_LD=no
47864 47864 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
47865 47865 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
47866 47866 $as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
47867 47867 $ECHO "SUNWprivate_1.1 { local: *; };" > version-script.map
47868 47868 $ECHO "int main() { }" > main.c
47869 47869 if $CXX -Wl,-version-script=version-script.map main.c 2>&5 >&5; then
47870 47870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
47871 47871 $as_echo "no" >&6; }
47872 47872 USING_BROKEN_SUSE_LD=no
47873 47873 else
47874 47874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
47875 47875 $as_echo "yes" >&6; }
47876 47876 USING_BROKEN_SUSE_LD=yes
47877 47877 fi
47878 47878 $RM version-script.map main.c a.out
47879 47879 fi
47880 47880
47881 47881
47882 47882 # Setup hotspot lecagy names for toolchains
47883 47883 HOTSPOT_TOOLCHAIN_TYPE=$TOOLCHAIN_TYPE
47884 47884 if test "x$TOOLCHAIN_TYPE" = xclang; then
47885 47885 HOTSPOT_TOOLCHAIN_TYPE=gcc
47886 47886 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
47887 47887 HOTSPOT_TOOLCHAIN_TYPE=sparcWorks
47888 47888 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
47889 47889 HOTSPOT_TOOLCHAIN_TYPE=visCPP
47890 47890 fi
47891 47891
47892 47892
47893 47893
47894 47894 # Setup the JTReg Regression Test Harness.
47895 47895
47896 47896
47897 47897 # Check whether --with-jtreg was given.
47898 47898 if test "${with_jtreg+set}" = set; then :
47899 47899 withval=$with_jtreg;
47900 47900 else
47901 47901 with_jtreg=no
47902 47902 fi
47903 47903
47904 47904
47905 47905 if test "x$with_jtreg" = xno; then
47906 47906 # jtreg disabled
47907 47907 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
47908 47908 $as_echo_n "checking for jtreg... " >&6; }
47909 47909 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
47910 47910 $as_echo "no" >&6; }
47911 47911 else
47912 47912 if test "x$with_jtreg" != xyes; then
47913 47913 # with path specified.
47914 47914 JT_HOME="$with_jtreg"
47915 47915 fi
47916 47916
47917 47917 if test "x$JT_HOME" != x; then
47918 47918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
47919 47919 $as_echo_n "checking for jtreg... " >&6; }
47920 47920
47921 47921 # use JT_HOME enviroment var.
47922 47922
47923 47923 # Only process if variable expands to non-empty
47924 47924
47925 47925 if test "x$JT_HOME" != x; then
47926 47926 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47927 47927
47928 47928 # Input might be given as Windows format, start by converting to
47929 47929 # unix format.
47930 47930 path="$JT_HOME"
47931 47931 new_path=`$CYGPATH -u "$path"`
47932 47932
47933 47933 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
47934 47934 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
47935 47935 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
47936 47936 # "foo.exe" is OK but "foo" is an error.
47937 47937 #
47938 47938 # This test is therefore slightly more accurate than "test -f" to check for file precense.
47939 47939 # It is also a way to make sure we got the proper file name for the real test later on.
47940 47940 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
47941 47941 if test "x$test_shortpath" = x; then
47942 47942 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
47943 47943 $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
47944 47944 as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
47945 47945 fi
47946 47946
47947 47947 # Call helper function which possibly converts this using DOS-style short mode.
47948 47948 # If so, the updated path is stored in $new_path.
47949 47949
47950 47950 input_path="$new_path"
47951 47951 # Check if we need to convert this using DOS-style short mode. If the path
47952 47952 # contains just simple characters, use it. Otherwise (spaces, weird characters),
47953 47953 # take no chances and rewrite it.
47954 47954 # Note: m4 eats our [], so we need to use [ and ] instead.
47955 47955 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
47956 47956 if test "x$has_forbidden_chars" != x; then
47957 47957 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
47958 47958 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
47959 47959 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
47960 47960 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
47961 47961 # Going to short mode and back again did indeed matter. Since short mode is
47962 47962 # case insensitive, let's make it lowercase to improve readability.
47963 47963 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
47964 47964 # Now convert it back to Unix-style (cygpath)
47965 47965 input_path=`$CYGPATH -u "$shortmode_path"`
47966 47966 new_path="$input_path"
47967 47967 fi
47968 47968 fi
47969 47969
47970 47970 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
47971 47971 if test "x$test_cygdrive_prefix" = x; then
47972 47972 # As a simple fix, exclude /usr/bin since it's not a real path.
47973 47973 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
47974 47974 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
47975 47975 # a path prefixed by /cygdrive for fixpath to work.
47976 47976 new_path="$CYGWIN_ROOT_PATH$input_path"
47977 47977 fi
47978 47978 fi
47979 47979
47980 47980
47981 47981 if test "x$path" != "x$new_path"; then
47982 47982 JT_HOME="$new_path"
47983 47983 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
47984 47984 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
47985 47985 fi
47986 47986
47987 47987 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47988 47988
47989 47989 path="$JT_HOME"
47990 47990 has_colon=`$ECHO $path | $GREP ^.:`
47991 47991 new_path="$path"
47992 47992 if test "x$has_colon" = x; then
47993 47993 # Not in mixed or Windows style, start by that.
47994 47994 new_path=`cmd //c echo $path`
47995 47995 fi
47996 47996
47997 47997
47998 47998 input_path="$new_path"
47999 47999 # Check if we need to convert this using DOS-style short mode. If the path
48000 48000 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48001 48001 # take no chances and rewrite it.
48002 48002 # Note: m4 eats our [], so we need to use [ and ] instead.
48003 48003 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48004 48004 if test "x$has_forbidden_chars" != x; then
48005 48005 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48006 48006 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48007 48007 fi
48008 48008
48009 48009
48010 48010 windows_path="$new_path"
48011 48011 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48012 48012 unix_path=`$CYGPATH -u "$windows_path"`
48013 48013 new_path="$unix_path"
48014 48014 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48015 48015 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48016 48016 new_path="$unix_path"
48017 48017 fi
48018 48018
48019 48019 if test "x$path" != "x$new_path"; then
48020 48020 JT_HOME="$new_path"
48021 48021 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
48022 48022 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
48023 48023 fi
48024 48024
48025 48025 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48026 48026 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48027 48027
48028 48028 else
48029 48029 # We're on a unix platform. Hooray! :)
48030 48030 path="$JT_HOME"
48031 48031 has_space=`$ECHO "$path" | $GREP " "`
48032 48032 if test "x$has_space" != x; then
48033 48033 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
48034 48034 $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
48035 48035 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48036 48036 fi
48037 48037
48038 48038 # Use eval to expand a potential ~
48039 48039 eval path="$path"
48040 48040 if test ! -f "$path" && test ! -d "$path"; then
48041 48041 as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
48042 48042 fi
48043 48043
48044 48044 if test -d "$path"; then
48045 48045 JT_HOME="`cd "$path"; $THEPWDCMD -L`"
48046 48046 else
48047 48047 dir="`$DIRNAME "$path"`"
48048 48048 base="`$BASENAME "$path"`"
48049 48049 JT_HOME="`cd "$dir"; $THEPWDCMD -L`/$base"
48050 48050 fi
48051 48051 fi
48052 48052 fi
48053 48053
48054 48054
48055 48055 # jtreg win32 script works for everybody
48056 48056 JTREGEXE="$JT_HOME/bin/jtreg"
48057 48057
48058 48058 if test ! -f "$JTREGEXE"; then
48059 48059 as_fn_error $? "JTReg executable does not exist: $JTREGEXE" "$LINENO" 5
48060 48060 fi
48061 48061
48062 48062 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
48063 48063 $as_echo "$JTREGEXE" >&6; }
48064 48064 else
48065 48065 # try to find jtreg on path
48066 48066
48067 48067
48068 48068
48069 48069 # Publish this variable in the help.
48070 48070
48071 48071
48072 48072 if [ -z "${JTREGEXE+x}" ]; then
48073 48073 # The variable is not set by user, try to locate tool using the code snippet
48074 48074 for ac_prog in jtreg
48075 48075 do
48076 48076 # Extract the first word of "$ac_prog", so it can be a program name with args.
48077 48077 set dummy $ac_prog; ac_word=$2
48078 48078 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
48079 48079 $as_echo_n "checking for $ac_word... " >&6; }
48080 48080 if ${ac_cv_path_JTREGEXE+:} false; then :
48081 48081 $as_echo_n "(cached) " >&6
48082 48082 else
48083 48083 case $JTREGEXE in
48084 48084 [\\/]* | ?:[\\/]*)
48085 48085 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
48086 48086 ;;
48087 48087 *)
48088 48088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
48089 48089 for as_dir in $PATH
48090 48090 do
48091 48091 IFS=$as_save_IFS
48092 48092 test -z "$as_dir" && as_dir=.
48093 48093 for ac_exec_ext in '' $ac_executable_extensions; do
48094 48094 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
48095 48095 ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
48096 48096 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
48097 48097 break 2
48098 48098 fi
48099 48099 done
48100 48100 done
48101 48101 IFS=$as_save_IFS
48102 48102
48103 48103 ;;
48104 48104 esac
48105 48105 fi
48106 48106 JTREGEXE=$ac_cv_path_JTREGEXE
48107 48107 if test -n "$JTREGEXE"; then
48108 48108 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
48109 48109 $as_echo "$JTREGEXE" >&6; }
48110 48110 else
48111 48111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48112 48112 $as_echo "no" >&6; }
48113 48113 fi
48114 48114
48115 48115
48116 48116 test -n "$JTREGEXE" && break
48117 48117 done
48118 48118
48119 48119 else
48120 48120 # The variable is set, but is it from the command line or the environment?
48121 48121
48122 48122 # Try to remove the string !JTREGEXE! from our list.
48123 48123 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JTREGEXE!/}
48124 48124 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
48125 48125 # If it failed, the variable was not from the command line. Ignore it,
48126 48126 # but warn the user (except for BASH, which is always set by the calling BASH).
48127 48127 if test "xJTREGEXE" != xBASH; then
48128 48128 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
48129 48129 $as_echo "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
48130 48130 fi
48131 48131 # Try to locate tool using the code snippet
48132 48132 for ac_prog in jtreg
48133 48133 do
48134 48134 # Extract the first word of "$ac_prog", so it can be a program name with args.
48135 48135 set dummy $ac_prog; ac_word=$2
48136 48136 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
48137 48137 $as_echo_n "checking for $ac_word... " >&6; }
48138 48138 if ${ac_cv_path_JTREGEXE+:} false; then :
48139 48139 $as_echo_n "(cached) " >&6
48140 48140 else
48141 48141 case $JTREGEXE in
48142 48142 [\\/]* | ?:[\\/]*)
48143 48143 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
48144 48144 ;;
48145 48145 *)
48146 48146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
48147 48147 for as_dir in $PATH
48148 48148 do
48149 48149 IFS=$as_save_IFS
48150 48150 test -z "$as_dir" && as_dir=.
48151 48151 for ac_exec_ext in '' $ac_executable_extensions; do
48152 48152 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
48153 48153 ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
48154 48154 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
48155 48155 break 2
48156 48156 fi
48157 48157 done
48158 48158 done
48159 48159 IFS=$as_save_IFS
48160 48160
48161 48161 ;;
48162 48162 esac
48163 48163 fi
48164 48164 JTREGEXE=$ac_cv_path_JTREGEXE
48165 48165 if test -n "$JTREGEXE"; then
48166 48166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
48167 48167 $as_echo "$JTREGEXE" >&6; }
48168 48168 else
48169 48169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48170 48170 $as_echo "no" >&6; }
48171 48171 fi
48172 48172
48173 48173
48174 48174 test -n "$JTREGEXE" && break
48175 48175 done
48176 48176
48177 48177 else
48178 48178 # If it succeeded, then it was overridden by the user. We will use it
48179 48179 # for the tool.
48180 48180
48181 48181 # First remove it from the list of overridden variables, so we can test
48182 48182 # for unknown variables in the end.
48183 48183 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
48184 48184
48185 48185 # Check if we try to supply an empty value
48186 48186 if test "x$JTREGEXE" = x; then
48187 48187 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JTREGEXE= (no value)" >&5
48188 48188 $as_echo "$as_me: Setting user supplied tool JTREGEXE= (no value)" >&6;}
48189 48189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
48190 48190 $as_echo_n "checking for JTREGEXE... " >&6; }
48191 48191 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
48192 48192 $as_echo "disabled" >&6; }
48193 48193 else
48194 48194 # Check if the provided tool contains a complete path.
48195 48195 tool_specified="$JTREGEXE"
48196 48196 tool_basename="${tool_specified##*/}"
48197 48197 if test "x$tool_basename" = "x$tool_specified"; then
48198 48198 # A command without a complete path is provided, search $PATH.
48199 48199 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
48200 48200 $as_echo "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
48201 48201 # Extract the first word of "$tool_basename", so it can be a program name with args.
48202 48202 set dummy $tool_basename; ac_word=$2
48203 48203 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
48204 48204 $as_echo_n "checking for $ac_word... " >&6; }
48205 48205 if ${ac_cv_path_JTREGEXE+:} false; then :
48206 48206 $as_echo_n "(cached) " >&6
48207 48207 else
48208 48208 case $JTREGEXE in
48209 48209 [\\/]* | ?:[\\/]*)
48210 48210 ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
48211 48211 ;;
48212 48212 *)
48213 48213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
48214 48214 for as_dir in $PATH
48215 48215 do
48216 48216 IFS=$as_save_IFS
48217 48217 test -z "$as_dir" && as_dir=.
48218 48218 for ac_exec_ext in '' $ac_executable_extensions; do
48219 48219 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
48220 48220 ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
48221 48221 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
48222 48222 break 2
48223 48223 fi
48224 48224 done
48225 48225 done
48226 48226 IFS=$as_save_IFS
48227 48227
48228 48228 ;;
48229 48229 esac
48230 48230 fi
48231 48231 JTREGEXE=$ac_cv_path_JTREGEXE
48232 48232 if test -n "$JTREGEXE"; then
48233 48233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
48234 48234 $as_echo "$JTREGEXE" >&6; }
48235 48235 else
48236 48236 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48237 48237 $as_echo "no" >&6; }
48238 48238 fi
48239 48239
48240 48240
48241 48241 if test "x$JTREGEXE" = x; then
48242 48242 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
48243 48243 fi
48244 48244 else
48245 48245 # Otherwise we believe it is a complete path. Use it as it is.
48246 48246 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
48247 48247 $as_echo "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
48248 48248 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
48249 48249 $as_echo_n "checking for JTREGEXE... " >&6; }
48250 48250 if test ! -x "$tool_specified"; then
48251 48251 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
48252 48252 $as_echo "not found" >&6; }
48253 48253 as_fn_error $? "User supplied tool JTREGEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
48254 48254 fi
48255 48255 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
48256 48256 $as_echo "$tool_specified" >&6; }
48257 48257 fi
48258 48258 fi
48259 48259 fi
48260 48260
48261 48261 fi
48262 48262
48263 48263
48264 48264
48265 48265 if test "x$JTREGEXE" = x; then
48266 48266 as_fn_error $? "Could not find required tool for JTREGEXE" "$LINENO" 5
48267 48267 fi
48268 48268
48269 48269
48270 48270 JT_HOME="`$DIRNAME $JTREGEXE`"
48271 48271 fi
48272 48272 fi
48273 48273
48274 48274
48275 48275
48276 48276
48277 48277
48278 48278
48279 48279 # COMPILER_TARGET_BITS_FLAG : option for selecting 32- or 64-bit output
48280 48280 # COMPILER_COMMAND_FILE_FLAG : option for passing a command file to the compiler
48281 48281 # COMPILER_BINDCMD_FILE_FLAG : option for specifying a file which saves the binder
48282 48282 # commands produced by the link step (currently AIX only)
48283 48283 if test "x$TOOLCHAIN_TYPE" = xxlc; then
48284 48284 COMPILER_TARGET_BITS_FLAG="-q"
48285 48285 COMPILER_COMMAND_FILE_FLAG="-f"
48286 48286 COMPILER_BINDCMD_FILE_FLAG="-bloadmap:"
48287 48287 else
48288 48288 COMPILER_TARGET_BITS_FLAG="-m"
48289 48289 COMPILER_COMMAND_FILE_FLAG="@"
48290 48290 COMPILER_BINDCMD_FILE_FLAG=""
48291 48291
48292 48292 # The solstudio linker does not support @-files.
48293 48293 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
48294 48294 COMPILER_COMMAND_FILE_FLAG=
48295 48295 fi
48296 48296
48297 48297 # Check if @file is supported by gcc
48298 48298 if test "x$TOOLCHAIN_TYPE" = xgcc; then
48299 48299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if @file is supported by gcc" >&5
48300 48300 $as_echo_n "checking if @file is supported by gcc... " >&6; }
48301 48301 # Extra emtpy "" to prevent ECHO from interpreting '--version' as argument
48302 48302 $ECHO "" "--version" > command.file
48303 48303 if $CXX @command.file 2>&5 >&5; then
48304 48304 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
48305 48305 $as_echo "yes" >&6; }
48306 48306 COMPILER_COMMAND_FILE_FLAG="@"
48307 48307 else
48308 48308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48309 48309 $as_echo "no" >&6; }
48310 48310 COMPILER_COMMAND_FILE_FLAG=
48311 48311 fi
48312 48312 $RM command.file
48313 48313 fi
48314 48314 fi
48315 48315
48316 48316
48317 48317
48318 48318
48319 48319 # FIXME: figure out if we should select AR flags depending on OS or toolchain.
48320 48320 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
48321 48321 ARFLAGS="-r"
48322 48322 elif test "x$OPENJDK_TARGET_OS" = xaix; then
48323 48323 ARFLAGS="-X64"
48324 48324 elif test "x$OPENJDK_TARGET_OS" = xwindows; then
48325 48325 # lib.exe is used as AR to create static libraries.
48326 48326 ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
48327 48327 else
48328 48328 ARFLAGS=""
48329 48329 fi
48330 48330
48331 48331
48332 48332 ## Setup strip.
48333 48333 # FIXME: should this really be per platform, or should it be per toolchain type?
48334 48334 # strip is not provided by clang or solstudio; so guessing platform makes most sense.
48335 48335 # FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD.
48336 48336 if test "x$OPENJDK_TARGET_OS" = xlinux; then
48337 48337 STRIPFLAGS="-g"
48338 48338 elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
48339 48339 STRIPFLAGS="-x"
48340 48340 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
48341 48341 STRIPFLAGS="-S"
48342 48342 elif test "x$OPENJDK_TARGET_OS" = xaix; then
48343 48343 STRIPFLAGS="-X32_64"
48344 48344 fi
48345 48345
48346 48346
48347 48347
48348 48348 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
48349 48349 CC_OUT_OPTION=-Fo
48350 48350 EXE_OUT_OPTION=-out:
48351 48351 LD_OUT_OPTION=-out:
48352 48352 AR_OUT_OPTION=-out:
48353 48353 else
48354 48354 # The option used to specify the target .o,.a or .so file.
48355 48355 # When compiling, how to specify the to be created object file.
48356 48356 CC_OUT_OPTION='-o$(SPACE)'
48357 48357 # When linking, how to specify the to be created executable.
48358 48358 EXE_OUT_OPTION='-o$(SPACE)'
48359 48359 # When linking, how to specify the to be created dynamically linkable library.
48360 48360 LD_OUT_OPTION='-o$(SPACE)'
48361 48361 # When archiving, how to specify the to be create static archive for object files.
48362 48362 AR_OUT_OPTION='rcs$(SPACE)'
48363 48363 fi
48364 48364
48365 48365
48366 48366
48367 48367
48368 48368
48369 48369 # On Windows, we need to set RC flags.
48370 48370 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
48371 48371 RC_FLAGS="-nologo -l0x409"
48372 48372 JVM_RCFLAGS="-nologo"
48373 48373 if test "x$DEBUG_LEVEL" = xrelease; then
48374 48374 RC_FLAGS="$RC_FLAGS -DNDEBUG"
48375 48375 JVM_RCFLAGS="$JVM_RCFLAGS -DNDEBUG"
48376 48376 fi
48377 48377
48378 48378 # The version variables used to create RC_FLAGS may be overridden
48379 48379 # in a custom configure script, or possibly the command line.
48380 48380 # Let those variables be expanded at make time in spec.gmk.
48381 48381 # The \$ are escaped to the shell, and the $(...) variables
48382 48382 # are evaluated by make.
48383 48383 RC_FLAGS="$RC_FLAGS \
48384 48384 -D\"JDK_VERSION_STRING=\$(VERSION_STRING)\" \
48385 48385 -D\"JDK_COMPANY=\$(COMPANY_NAME)\" \
48386 48386 -D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
48387 48387 -D\"JDK_VER=\$(VERSION_NUMBER)\" \
48388 48388 -D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
48389 48389 -D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(VERSION_MAJOR)\" \
48390 48390 -D\"JDK_FVER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\""
48391 48391
48392 48392 JVM_RCFLAGS="$JVM_RCFLAGS \
48393 48393 -D\"HS_BUILD_ID=\$(VERSION_STRING)\" \
48394 48394 -D\"HS_COMPANY=\$(COMPANY_NAME)\" \
48395 48395 -D\"JDK_DOTVER=\$(VERSION_NUMBER_FOUR_POSITIONS)\" \
48396 48396 -D\"HS_COPYRIGHT=Copyright $COPYRIGHT_YEAR\" \
48397 48397 -D\"HS_NAME=\$(PRODUCT_NAME) \$(VERSION_SHORT)\" \
48398 48398 -D\"JDK_VER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\" \
48399 48399 -D\"HS_FNAME=jvm.dll\" \
48400 48400 -D\"HS_INTERNAL_NAME=jvm\""
48401 48401 fi
48402 48402
48403 48403
48404 48404
48405 48405 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
48406 48406 # silence copyright notice and other headers.
48407 48407 COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
48408 48408 fi
48409 48409
48410 48410
48411 48411 # Now we can test some aspects on the target using configure macros.
48412 48412
48413 48413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
48414 48414 $as_echo_n "checking for ANSI C header files... " >&6; }
48415 48415 if ${ac_cv_header_stdc+:} false; then :
48416 48416 $as_echo_n "(cached) " >&6
48417 48417 else
48418 48418 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48419 48419 /* end confdefs.h. */
48420 48420 #include <stdlib.h>
48421 48421 #include <stdarg.h>
48422 48422 #include <string.h>
48423 48423 #include <float.h>
48424 48424
48425 48425 int
48426 48426 main ()
48427 48427 {
48428 48428
48429 48429 ;
48430 48430 return 0;
48431 48431 }
48432 48432 _ACEOF
48433 48433 if ac_fn_cxx_try_compile "$LINENO"; then :
48434 48434 ac_cv_header_stdc=yes
48435 48435 else
48436 48436 ac_cv_header_stdc=no
48437 48437 fi
48438 48438 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48439 48439
48440 48440 if test $ac_cv_header_stdc = yes; then
48441 48441 # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
48442 48442 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48443 48443 /* end confdefs.h. */
48444 48444 #include <string.h>
48445 48445
48446 48446 _ACEOF
48447 48447 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
48448 48448 $EGREP "memchr" >/dev/null 2>&1; then :
48449 48449
48450 48450 else
48451 48451 ac_cv_header_stdc=no
48452 48452 fi
48453 48453 rm -f conftest*
48454 48454
48455 48455 fi
48456 48456
48457 48457 if test $ac_cv_header_stdc = yes; then
48458 48458 # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
48459 48459 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48460 48460 /* end confdefs.h. */
48461 48461 #include <stdlib.h>
48462 48462
48463 48463 _ACEOF
48464 48464 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
48465 48465 $EGREP "free" >/dev/null 2>&1; then :
48466 48466
48467 48467 else
48468 48468 ac_cv_header_stdc=no
48469 48469 fi
48470 48470 rm -f conftest*
48471 48471
48472 48472 fi
48473 48473
48474 48474 if test $ac_cv_header_stdc = yes; then
48475 48475 # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
48476 48476 if test "$cross_compiling" = yes; then :
48477 48477 :
48478 48478 else
48479 48479 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48480 48480 /* end confdefs.h. */
48481 48481 #include <ctype.h>
48482 48482 #include <stdlib.h>
48483 48483 #if ((' ' & 0x0FF) == 0x020)
48484 48484 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
48485 48485 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
48486 48486 #else
48487 48487 # define ISLOWER(c) \
48488 48488 (('a' <= (c) && (c) <= 'i') \
48489 48489 || ('j' <= (c) && (c) <= 'r') \
48490 48490 || ('s' <= (c) && (c) <= 'z'))
48491 48491 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
48492 48492 #endif
48493 48493
48494 48494 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
48495 48495 int
48496 48496 main ()
48497 48497 {
48498 48498 int i;
48499 48499 for (i = 0; i < 256; i++)
48500 48500 if (XOR (islower (i), ISLOWER (i))
48501 48501 || toupper (i) != TOUPPER (i))
48502 48502 return 2;
48503 48503 return 0;
48504 48504 }
48505 48505 _ACEOF
48506 48506 if ac_fn_cxx_try_run "$LINENO"; then :
48507 48507
48508 48508 else
48509 48509 ac_cv_header_stdc=no
48510 48510 fi
48511 48511 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
48512 48512 conftest.$ac_objext conftest.beam conftest.$ac_ext
48513 48513 fi
48514 48514
48515 48515 fi
48516 48516 fi
48517 48517 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
48518 48518 $as_echo "$ac_cv_header_stdc" >&6; }
48519 48519 if test $ac_cv_header_stdc = yes; then
48520 48520
48521 48521 $as_echo "#define STDC_HEADERS 1" >>confdefs.h
48522 48522
48523 48523 fi
48524 48524
48525 48525 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
48526 48526 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
48527 48527 inttypes.h stdint.h unistd.h
48528 48528 do :
48529 48529 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
48530 48530 ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
48531 48531 "
48532 48532 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
48533 48533 cat >>confdefs.h <<_ACEOF
48534 48534 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
48535 48535 _ACEOF
48536 48536
48537 48537 fi
48538 48538
48539 48539 done
48540 48540
48541 48541
48542 48542
48543 48543 ###############################################################################
48544 48544 #
48545 48545 # Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code.
48546 48546 # (The JVM can use 32 or 64 bit Java pointers but that decision
48547 48547 # is made at runtime.)
48548 48548 #
48549 48549
48550 48550 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xaix; then
48551 48551 # Always specify -m flag on Solaris
48552 48552 # And -q on AIX because otherwise the compiler produces 32-bit objects by default
48553 48553
48554 48554 # When we add flags to the "official" CFLAGS etc, we need to
48555 48555 # keep track of these additions in ADDED_CFLAGS etc. These
48556 48556 # will later be checked to make sure only controlled additions
48557 48557 # have been made to CFLAGS etc.
48558 48558 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48559 48559 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48560 48560 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48561 48561
48562 48562 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
48563 48563 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
48564 48564 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
48565 48565
48566 48566 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
48567 48567 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
48568 48568 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
48569 48569
48570 48570 JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
48571 48571 JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
48572 48572 JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
48573 48573
48574 48574 elif test "x$COMPILE_TYPE" = xreduced; then
48575 48575 if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
48576 48576 # Specify -m if running reduced on unix platforms
48577 48577
48578 48578 # When we add flags to the "official" CFLAGS etc, we need to
48579 48579 # keep track of these additions in ADDED_CFLAGS etc. These
48580 48580 # will later be checked to make sure only controlled additions
48581 48581 # have been made to CFLAGS etc.
48582 48582 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48583 48583 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48584 48584 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48585 48585
48586 48586 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
48587 48587 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
48588 48588 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
48589 48589
48590 48590 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
48591 48591 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
48592 48592 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
48593 48593
48594 48594 JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
48595 48595 JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
48596 48596 JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
48597 48597
48598 48598 fi
48599 48599 fi
48600 48600 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
48601 48601 JVM_CFLAGS="$JVM_CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48602 48602 JVM_LDFLAGS="$JVM_LDFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48603 48603 JVM_ASFLAGS="$JVM_ASFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48604 48604 fi
48605 48605
48606 48606 # Make compilation sanity check
48607 48607 for ac_header in stdio.h
48608 48608 do :
48609 48609 ac_fn_cxx_check_header_mongrel "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
48610 48610 if test "x$ac_cv_header_stdio_h" = xyes; then :
48611 48611 cat >>confdefs.h <<_ACEOF
48612 48612 #define HAVE_STDIO_H 1
48613 48613 _ACEOF
48614 48614
48615 48615 else
48616 48616
48617 48617 { $as_echo "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
48618 48618 $as_echo "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
48619 48619 if test "x$COMPILE_TYPE" = xreduced; then
48620 48620
48621 48621 # Print a helpful message on how to acquire the necessary build dependency.
48622 48622 # reduced is the help tag: freetype, cups, alsa etc
48623 48623 MISSING_DEPENDENCY=reduced
48624 48624
48625 48625 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48626 48626 cygwin_help $MISSING_DEPENDENCY
48627 48627 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48628 48628 msys_help $MISSING_DEPENDENCY
48629 48629 else
48630 48630 PKGHANDLER_COMMAND=
48631 48631
48632 48632 case $PKGHANDLER in
48633 48633 apt-get)
48634 48634 apt_help $MISSING_DEPENDENCY ;;
48635 48635 yum)
48636 48636 yum_help $MISSING_DEPENDENCY ;;
48637 48637 port)
48638 48638 port_help $MISSING_DEPENDENCY ;;
48639 48639 pkgutil)
48640 48640 pkgutil_help $MISSING_DEPENDENCY ;;
48641 48641 pkgadd)
48642 48642 pkgadd_help $MISSING_DEPENDENCY ;;
48643 48643 esac
48644 48644
48645 48645 if test "x$PKGHANDLER_COMMAND" != x; then
48646 48646 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
48647 48647 fi
48648 48648 fi
48649 48649
48650 48650 { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&5
48651 48651 $as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&6;}
48652 48652 elif test "x$COMPILE_TYPE" = xcross; then
48653 48653 { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
48654 48654 $as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
48655 48655 fi
48656 48656 as_fn_error $? "Cannot continue." "$LINENO" 5
48657 48657
48658 48658 fi
48659 48659
48660 48660 done
48661 48661
48662 48662
48663 48663 # The cast to long int works around a bug in the HP C Compiler
48664 48664 # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
48665 48665 # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
48666 48666 # This bug is HP SR number 8606223364.
48667 48667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
48668 48668 $as_echo_n "checking size of int *... " >&6; }
48669 48669 if ${ac_cv_sizeof_int_p+:} false; then :
48670 48670 $as_echo_n "(cached) " >&6
48671 48671 else
48672 48672 if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then :
48673 48673
48674 48674 else
48675 48675 if test "$ac_cv_type_int_p" = yes; then
48676 48676 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
48677 48677 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
48678 48678 as_fn_error 77 "cannot compute sizeof (int *)
48679 48679 See \`config.log' for more details" "$LINENO" 5; }
48680 48680 else
48681 48681 ac_cv_sizeof_int_p=0
48682 48682 fi
48683 48683 fi
48684 48684
48685 48685 fi
48686 48686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
48687 48687 $as_echo "$ac_cv_sizeof_int_p" >&6; }
48688 48688
48689 48689
48690 48690
48691 48691 cat >>confdefs.h <<_ACEOF
48692 48692 #define SIZEOF_INT_P $ac_cv_sizeof_int_p
48693 48693 _ACEOF
48694 48694
48695 48695
48696 48696
48697 48697 # AC_CHECK_SIZEOF defines 'ac_cv_sizeof_int_p' to hold the number of bytes used by an 'int*'
48698 48698 if test "x$ac_cv_sizeof_int_p" = x; then
48699 48699 # The test failed, lets stick to the assumed value.
48700 48700 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
48701 48701 $as_echo "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
48702 48702 else
48703 48703 TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
48704 48704
48705 48705 if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
48706 48706 # This situation may happen on 64-bit platforms where the compiler by default only generates 32-bit objects
48707 48707 # Let's try to implicitely set the compilers target architecture and retry the test
48708 48708 { $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
48709 48709 $as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
48710 48710 { $as_echo "$as_me:${as_lineno-$LINENO}: Retrying with platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
48711 48711 $as_echo "$as_me: Retrying with platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
48712 48712
48713 48713 # When we add flags to the "official" CFLAGS etc, we need to
48714 48714 # keep track of these additions in ADDED_CFLAGS etc. These
48715 48715 # will later be checked to make sure only controlled additions
48716 48716 # have been made to CFLAGS etc.
48717 48717 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48718 48718 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48719 48719 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
48720 48720
48721 48721 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
48722 48722 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
48723 48723 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
48724 48724
48725 48725 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
48726 48726 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
48727 48727 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
48728 48728
48729 48729 JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
48730 48730 JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
48731 48731 JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
48732 48732
48733 48733
48734 48734 # We have to unset 'ac_cv_sizeof_int_p' first, otherwise AC_CHECK_SIZEOF will use the previously cached value!
48735 48735 unset ac_cv_sizeof_int_p
48736 48736 # And we have to undef the definition of SIZEOF_INT_P in confdefs.h by the previous invocation of AC_CHECK_SIZEOF
48737 48737 cat >>confdefs.h <<_ACEOF
48738 48738 #undef SIZEOF_INT_P
48739 48739 _ACEOF
48740 48740
48741 48741 # The cast to long int works around a bug in the HP C Compiler
48742 48742 # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
48743 48743 # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
48744 48744 # This bug is HP SR number 8606223364.
48745 48745 { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
48746 48746 $as_echo_n "checking size of int *... " >&6; }
48747 48747 if ${ac_cv_sizeof_int_p+:} false; then :
48748 48748 $as_echo_n "(cached) " >&6
48749 48749 else
48750 48750 if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then :
48751 48751
48752 48752 else
48753 48753 if test "$ac_cv_type_int_p" = yes; then
48754 48754 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
48755 48755 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
48756 48756 as_fn_error 77 "cannot compute sizeof (int *)
48757 48757 See \`config.log' for more details" "$LINENO" 5; }
48758 48758 else
48759 48759 ac_cv_sizeof_int_p=0
48760 48760 fi
48761 48761 fi
48762 48762
48763 48763 fi
48764 48764 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
48765 48765 $as_echo "$ac_cv_sizeof_int_p" >&6; }
48766 48766
48767 48767
48768 48768
48769 48769 cat >>confdefs.h <<_ACEOF
48770 48770 #define SIZEOF_INT_P $ac_cv_sizeof_int_p
48771 48771 _ACEOF
48772 48772
48773 48773
48774 48774
48775 48775 TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
48776 48776
48777 48777 if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
48778 48778 { $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)" >&5
48779 48779 $as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)" >&6;}
48780 48780 if test "x$COMPILE_TYPE" = xreduced; then
48781 48781
48782 48782 # Print a helpful message on how to acquire the necessary build dependency.
48783 48783 # reduced is the help tag: freetype, cups, alsa etc
48784 48784 MISSING_DEPENDENCY=reduced
48785 48785
48786 48786 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48787 48787 cygwin_help $MISSING_DEPENDENCY
48788 48788 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48789 48789 msys_help $MISSING_DEPENDENCY
48790 48790 else
48791 48791 PKGHANDLER_COMMAND=
48792 48792
48793 48793 case $PKGHANDLER in
48794 48794 apt-get)
48795 48795 apt_help $MISSING_DEPENDENCY ;;
48796 48796 yum)
48797 48797 yum_help $MISSING_DEPENDENCY ;;
48798 48798 port)
48799 48799 port_help $MISSING_DEPENDENCY ;;
48800 48800 pkgutil)
48801 48801 pkgutil_help $MISSING_DEPENDENCY ;;
48802 48802 pkgadd)
48803 48803 pkgadd_help $MISSING_DEPENDENCY ;;
48804 48804 esac
48805 48805
48806 48806 if test "x$PKGHANDLER_COMMAND" != x; then
48807 48807 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
48808 48808 fi
48809 48809 fi
48810 48810
48811 48811 { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&5
48812 48812 $as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&6;}
48813 48813 elif test "x$COMPILE_TYPE" = xcross; then
48814 48814 { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
48815 48815 $as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
48816 48816 fi
48817 48817 as_fn_error $? "Cannot continue." "$LINENO" 5
48818 48818 fi
48819 48819 fi
48820 48820 fi
48821 48821
48822 48822 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
48823 48823 $as_echo_n "checking for target address size... " >&6; }
48824 48824 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
48825 48825 $as_echo "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
48826 48826
48827 48827
48828 48828 ###############################################################################
48829 48829 #
48830 48830 # Is the target little of big endian?
48831 48831 #
48832 48832 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
48833 48833 $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
48834 48834 if ${ac_cv_c_bigendian+:} false; then :
48835 48835 $as_echo_n "(cached) " >&6
48836 48836 else
48837 48837 ac_cv_c_bigendian=unknown
48838 48838 # See if we're dealing with a universal compiler.
48839 48839 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48840 48840 /* end confdefs.h. */
48841 48841 #ifndef __APPLE_CC__
48842 48842 not a universal capable compiler
48843 48843 #endif
48844 48844 typedef int dummy;
48845 48845
48846 48846 _ACEOF
48847 48847 if ac_fn_cxx_try_compile "$LINENO"; then :
48848 48848
48849 48849 # Check for potential -arch flags. It is not universal unless
48850 48850 # there are at least two -arch flags with different values.
48851 48851 ac_arch=
48852 48852 ac_prev=
48853 48853 for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
48854 48854 if test -n "$ac_prev"; then
48855 48855 case $ac_word in
48856 48856 i?86 | x86_64 | ppc | ppc64)
48857 48857 if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
48858 48858 ac_arch=$ac_word
48859 48859 else
48860 48860 ac_cv_c_bigendian=universal
48861 48861 break
48862 48862 fi
48863 48863 ;;
48864 48864 esac
48865 48865 ac_prev=
48866 48866 elif test "x$ac_word" = "x-arch"; then
48867 48867 ac_prev=arch
48868 48868 fi
48869 48869 done
48870 48870 fi
48871 48871 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48872 48872 if test $ac_cv_c_bigendian = unknown; then
48873 48873 # See if sys/param.h defines the BYTE_ORDER macro.
48874 48874 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48875 48875 /* end confdefs.h. */
48876 48876 #include <sys/types.h>
48877 48877 #include <sys/param.h>
48878 48878
48879 48879 int
48880 48880 main ()
48881 48881 {
48882 48882 #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
48883 48883 && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
48884 48884 && LITTLE_ENDIAN)
48885 48885 bogus endian macros
48886 48886 #endif
48887 48887
48888 48888 ;
48889 48889 return 0;
48890 48890 }
48891 48891 _ACEOF
48892 48892 if ac_fn_cxx_try_compile "$LINENO"; then :
48893 48893 # It does; now see whether it defined to BIG_ENDIAN or not.
48894 48894 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48895 48895 /* end confdefs.h. */
48896 48896 #include <sys/types.h>
48897 48897 #include <sys/param.h>
48898 48898
48899 48899 int
48900 48900 main ()
48901 48901 {
48902 48902 #if BYTE_ORDER != BIG_ENDIAN
48903 48903 not big endian
48904 48904 #endif
48905 48905
48906 48906 ;
48907 48907 return 0;
48908 48908 }
48909 48909 _ACEOF
48910 48910 if ac_fn_cxx_try_compile "$LINENO"; then :
48911 48911 ac_cv_c_bigendian=yes
48912 48912 else
48913 48913 ac_cv_c_bigendian=no
48914 48914 fi
48915 48915 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48916 48916 fi
48917 48917 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48918 48918 fi
48919 48919 if test $ac_cv_c_bigendian = unknown; then
48920 48920 # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
48921 48921 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48922 48922 /* end confdefs.h. */
48923 48923 #include <limits.h>
48924 48924
48925 48925 int
48926 48926 main ()
48927 48927 {
48928 48928 #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
48929 48929 bogus endian macros
48930 48930 #endif
48931 48931
48932 48932 ;
48933 48933 return 0;
48934 48934 }
48935 48935 _ACEOF
48936 48936 if ac_fn_cxx_try_compile "$LINENO"; then :
48937 48937 # It does; now see whether it defined to _BIG_ENDIAN or not.
48938 48938 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48939 48939 /* end confdefs.h. */
48940 48940 #include <limits.h>
48941 48941
48942 48942 int
48943 48943 main ()
48944 48944 {
48945 48945 #ifndef _BIG_ENDIAN
48946 48946 not big endian
48947 48947 #endif
48948 48948
48949 48949 ;
48950 48950 return 0;
48951 48951 }
48952 48952 _ACEOF
48953 48953 if ac_fn_cxx_try_compile "$LINENO"; then :
48954 48954 ac_cv_c_bigendian=yes
48955 48955 else
48956 48956 ac_cv_c_bigendian=no
48957 48957 fi
48958 48958 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48959 48959 fi
48960 48960 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
48961 48961 fi
48962 48962 if test $ac_cv_c_bigendian = unknown; then
48963 48963 # Compile a test program.
48964 48964 if test "$cross_compiling" = yes; then :
48965 48965 # Try to guess by grepping values from an object file.
48966 48966 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
48967 48967 /* end confdefs.h. */
48968 48968 short int ascii_mm[] =
48969 48969 { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
48970 48970 short int ascii_ii[] =
48971 48971 { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
48972 48972 int use_ascii (int i) {
48973 48973 return ascii_mm[i] + ascii_ii[i];
48974 48974 }
48975 48975 short int ebcdic_ii[] =
48976 48976 { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
48977 48977 short int ebcdic_mm[] =
48978 48978 { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
48979 48979 int use_ebcdic (int i) {
48980 48980 return ebcdic_mm[i] + ebcdic_ii[i];
48981 48981 }
48982 48982 extern int foo;
48983 48983
48984 48984 int
48985 48985 main ()
48986 48986 {
48987 48987 return use_ascii (foo) == use_ebcdic (foo);
48988 48988 ;
48989 48989 return 0;
48990 48990 }
48991 48991 _ACEOF
48992 48992 if ac_fn_cxx_try_compile "$LINENO"; then :
48993 48993 if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
48994 48994 ac_cv_c_bigendian=yes
48995 48995 fi
48996 48996 if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
48997 48997 if test "$ac_cv_c_bigendian" = unknown; then
48998 48998 ac_cv_c_bigendian=no
48999 48999 else
49000 49000 # finding both strings is unlikely to happen, but who knows?
49001 49001 ac_cv_c_bigendian=unknown
49002 49002 fi
49003 49003 fi
49004 49004 fi
49005 49005 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
49006 49006 else
49007 49007 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
49008 49008 /* end confdefs.h. */
49009 49009 $ac_includes_default
49010 49010 int
49011 49011 main ()
49012 49012 {
49013 49013
49014 49014 /* Are we little or big endian? From Harbison&Steele. */
49015 49015 union
49016 49016 {
49017 49017 long int l;
49018 49018 char c[sizeof (long int)];
49019 49019 } u;
49020 49020 u.l = 1;
49021 49021 return u.c[sizeof (long int) - 1] == 1;
49022 49022
49023 49023 ;
49024 49024 return 0;
49025 49025 }
49026 49026 _ACEOF
49027 49027 if ac_fn_cxx_try_run "$LINENO"; then :
49028 49028 ac_cv_c_bigendian=no
49029 49029 else
49030 49030 ac_cv_c_bigendian=yes
49031 49031 fi
49032 49032 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
49033 49033 conftest.$ac_objext conftest.beam conftest.$ac_ext
49034 49034 fi
49035 49035
49036 49036 fi
49037 49037 fi
49038 49038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
49039 49039 $as_echo "$ac_cv_c_bigendian" >&6; }
49040 49040 case $ac_cv_c_bigendian in #(
49041 49041 yes)
49042 49042 ENDIAN="big";; #(
49043 49043 no)
49044 49044 ENDIAN="little" ;; #(
49045 49045 universal)
49046 49046 ENDIAN="universal_endianness"
49047 49047 ;; #(
49048 49048 *)
49049 49049 ENDIAN="unknown" ;;
49050 49050 esac
49051 49051
49052 49052
49053 49053 if test "x$ENDIAN" = xuniversal_endianness; then
49054 49054 as_fn_error $? "Building with both big and little endianness is not supported" "$LINENO" 5
49055 49055 fi
49056 49056 if test "x$ENDIAN" != "x$OPENJDK_TARGET_CPU_ENDIAN"; then
49057 49057 as_fn_error $? "The tested endian in the target ($ENDIAN) differs from the endian expected to be found in the target ($OPENJDK_TARGET_CPU_ENDIAN)" "$LINENO" 5
49058 49058 fi
49059 49059
49060 49060
49061 49061 # Configure flags for the tools
49062 49062
49063 49063 ###############################################################################
49064 49064 #
49065 49065 # How to compile shared libraries.
49066 49066 #
49067 49067
49068 49068 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49069 49069 PICFLAG="-fPIC"
49070 49070 C_FLAG_REORDER=''
49071 49071 CXX_FLAG_REORDER=''
49072 49072
49073 49073 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49074 49074 # Linking is different on MacOSX
49075 49075 if test "x$STATIC_BUILD" = xtrue; then
49076 49076 SHARED_LIBRARY_FLAGS ='-undefined dynamic_lookup'
49077 49077 else
49078 49078 SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
49079 49079 JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
49080 49080 fi
49081 49081 SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path/.'
49082 49082 SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
49083 49083 SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/$1'
49084 49084 SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,$1'
49085 49085 else
49086 49086 # Default works for linux, might work on other platforms as well.
49087 49087 SHARED_LIBRARY_FLAGS='-shared'
49088 49088 SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$$$ORIGIN$1'
49089 49089 SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
49090 49090 SET_SHARED_LIBRARY_NAME='-Wl,-soname=$1'
49091 49091 SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=$1'
49092 49092 fi
49093 49093 elif test "x$TOOLCHAIN_TYPE" = xclang; then
49094 49094 C_FLAG_REORDER=''
49095 49095 CXX_FLAG_REORDER=''
49096 49096
49097 49097 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49098 49098 # Linking is different on MacOSX
49099 49099 PICFLAG=''
49100 49100 SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
49101 49101 SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path/.'
49102 49102 SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
49103 49103 SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/$1'
49104 49104 SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,$1'
49105 49105
49106 49106 if test "x$STATIC_BUILD" = xfalse; then
49107 49107 JVM_CFLAGS="$JVM_CFLAGS -fPIC"
49108 49108 fi
49109 49109 else
49110 49110 # Default works for linux, might work on other platforms as well.
49111 49111 PICFLAG='-fPIC'
49112 49112 SHARED_LIBRARY_FLAGS='-shared'
49113 49113 SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$$$ORIGIN$1'
49114 49114 SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
49115 49115 SET_SHARED_LIBRARY_NAME='-Wl,-soname=$1'
49116 49116 SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=$1'
49117 49117 fi
49118 49118 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49119 49119 PICFLAG="-KPIC"
49120 49120 C_FLAG_REORDER='-xF'
49121 49121 CXX_FLAG_REORDER='-xF'
49122 49122 SHARED_LIBRARY_FLAGS="-G"
49123 49123 SET_EXECUTABLE_ORIGIN='-R\$$$$ORIGIN$1'
49124 49124 SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
49125 49125 SET_SHARED_LIBRARY_NAME='-h $1'
49126 49126 SET_SHARED_LIBRARY_MAPFILE='-M$1'
49127 49127 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
49128 49128 # '-qpic' defaults to 'qpic=small'. This means that the compiler generates only
49129 49129 # one instruction for accessing the TOC. If the TOC grows larger than 64K, the linker
49130 49130 # will have to patch this single instruction with a call to some out-of-order code which
49131 49131 # does the load from the TOC. This is of course slow. But in that case we also would have
49132 49132 # to use '-bbigtoc' for linking anyway so we could also change the PICFLAG to 'qpic=large'.
49133 49133 # With 'qpic=large' the compiler will by default generate a two-instruction sequence which
49134 49134 # can be patched directly by the linker and does not require a jump to out-of-order code.
49135 49135 # Another alternative instead of using 'qpic=large -bbigtoc' may be to use '-qminimaltoc'
49136 49136 # instead. This creates a distinct TOC for every compilation unit (and thus requires two
49137 49137 # loads for accessing a global variable). But there are rumors that this may be seen as a
49138 49138 # 'performance feature' because of improved code locality of the symbols used in a
49139 49139 # compilation unit.
49140 49140 PICFLAG="-qpic"
49141 49141 JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
49142 49142 C_FLAG_REORDER=''
49143 49143 CXX_FLAG_REORDER=''
49144 49144 SHARED_LIBRARY_FLAGS="-qmkshrobj -bM:SRE -bnoentry"
49145 49145 SET_EXECUTABLE_ORIGIN=""
49146 49146 SET_SHARED_LIBRARY_ORIGIN=''
49147 49147 SET_SHARED_LIBRARY_NAME=''
49148 49148 SET_SHARED_LIBRARY_MAPFILE=''
49149 49149 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49150 49150 PICFLAG=""
49151 49151 C_FLAG_REORDER=''
49152 49152 CXX_FLAG_REORDER=''
49153 49153 SHARED_LIBRARY_FLAGS="-dll"
49154 49154 SET_EXECUTABLE_ORIGIN=''
49155 49155 SET_SHARED_LIBRARY_ORIGIN=''
49156 49156 SET_SHARED_LIBRARY_NAME=''
49157 49157 SET_SHARED_LIBRARY_MAPFILE='-def:$1'
49158 49158 fi
49159 49159
49160 49160
49161 49161
49162 49162
49163 49163
49164 49164
49165 49165
49166 49166
49167 49167
49168 49168 # The (cross) compiler is now configured, we can now test capabilities
49169 49169 # of the target platform.
49170 49170
49171 49171
49172 49172
49173 49173 ###############################################################################
49174 49174 #
49175 49175 # Setup the opt flags for different compilers
49176 49176 # and different operating systems.
49177 49177 #
49178 49178
49179 49179 # FIXME: this was indirectly the old default, but just inherited.
49180 49180 # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49181 49181 # C_FLAG_DEPS="-MMD -MF"
49182 49182 # fi
49183 49183
49184 49184 # Generate make dependency files
49185 49185 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49186 49186 C_FLAG_DEPS="-MMD -MF"
49187 49187 elif test "x$TOOLCHAIN_TYPE" = xclang; then
49188 49188 C_FLAG_DEPS="-MMD -MF"
49189 49189 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49190 49190 C_FLAG_DEPS="-xMMD -xMF"
49191 49191 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
49192 49192 C_FLAG_DEPS="-qmakedep=gcc -MF"
49193 49193 fi
49194 49194 CXX_FLAG_DEPS="$C_FLAG_DEPS"
49195 49195
49196 49196
49197 49197
49198 49198 # Debug symbols
49199 49199 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49200 49200 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
49201 49201 # reduce from default "-g2" option to save space
49202 49202 CFLAGS_DEBUG_SYMBOLS="-g1"
49203 49203 CXXFLAGS_DEBUG_SYMBOLS="-g1"
49204 49204 else
49205 49205 CFLAGS_DEBUG_SYMBOLS="-g"
49206 49206 CXXFLAGS_DEBUG_SYMBOLS="-g"
49207 49207 fi
49208 49208 elif test "x$TOOLCHAIN_TYPE" = xclang; then
49209 49209 CFLAGS_DEBUG_SYMBOLS="-g"
49210 49210 CXXFLAGS_DEBUG_SYMBOLS="-g"
49211 49211 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49212 49212 CFLAGS_DEBUG_SYMBOLS="-g -xs"
49213 49213 # -g0 enables debug symbols without disabling inlining.
49214 49214 CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
49215 49215 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
49216 49216 CFLAGS_DEBUG_SYMBOLS="-g"
49217 49217 CXXFLAGS_DEBUG_SYMBOLS="-g"
49218 49218 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49219 49219 CFLAGS_DEBUG_SYMBOLS="-Zi"
49220 49220 CXXFLAGS_DEBUG_SYMBOLS="-Zi"
49221 49221 fi
49222 49222
49223 49223
49224 49224
49225 49225 # Debug symbols for JVM_CFLAGS
49226 49226 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49227 49227 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"
49228 49228 if test "x$DEBUG_LEVEL" = xslowdebug; then
49229 49229 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
49230 49230 else
49231 49231 # -g0 does not disable inlining, which -g does.
49232 49232 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g0"
49233 49233 fi
49234 49234 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49235 49235 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -Z7 -d2Zi+"
49236 49236 else
49237 49237 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
49238 49238 fi
49239 49239
49240 49240
49241 49241 # bounds, memory and behavior checking options
49242 49242 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49243 49243 case $DEBUG_LEVEL in
49244 49244 release )
49245 49245 # no adjustment
49246 49246 ;;
49247 49247 fastdebug )
49248 49248 # no adjustment
49249 49249 ;;
49250 49250 slowdebug )
49251 49251 # FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it
49252 49252 # get's added conditionally on whether we produce debug symbols or not.
49253 49253 # This is most likely not really correct.
49254 49254
49255 49255 # Add runtime stack smashing and undefined behavior checks.
49256 49256 # Not all versions of gcc support -fstack-protector
49257 49257 STACK_PROTECTOR_CFLAG="-fstack-protector-all"
49258 49258
49259 49259
49260 49260
49261 49261
49262 49262
49263 49263
49264 49264
49265 49265
49266 49266
49267 49267
49268 49268
49269 49269
49270 49270
49271 49271
49272 49272
49273 49273
49274 49274
49275 49275
49276 49276
49277 49277
49278 49278
49279 49279
49280 49280
49281 49281
49282 49282
49283 49283
49284 49284
49285 49285
49286 49286
49287 49287
49288 49288
49289 49289
49290 49290
49291 49291
49292 49292
49293 49293
49294 49294
49295 49295
49296 49296
49297 49297
49298 49298
49299 49299
49300 49300 # Execute function body
49301 49301
49302 49302
49303 49303
49304 49304
49305 49305
49306 49306
49307 49307
49308 49308
49309 49309
49310 49310
49311 49311
49312 49312
49313 49313
49314 49314
49315 49315
49316 49316
49317 49317
49318 49318
49319 49319
49320 49320
49321 49321
49322 49322
49323 49323
49324 49324
49325 49325
49326 49326
49327 49327
49328 49328
49329 49329
49330 49330
49331 49331
49332 49332
49333 49333
49334 49334
49335 49335
49336 49336
49337 49337
49338 49338
49339 49339
49340 49340
49341 49341
49342 49342
49343 49343
49344 49344
49345 49345
49346 49346
49347 49347
49348 49348
49349 49349 # Execute function body
49350 49350
49351 49351 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
49352 49352 $as_echo_n "checking if the C compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
49353 49353 supports=yes
49354 49354
49355 49355 saved_cflags="$CFLAGS"
49356 49356 CFLAGS="$CFLAGS $STACK_PROTECTOR_CFLAG -Werror"
49357 49357 ac_ext=c
49358 49358 ac_cpp='$CPP $CPPFLAGS'
49359 49359 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49360 49360 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49361 49361 ac_compiler_gnu=$ac_cv_c_compiler_gnu
49362 49362
49363 49363 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
49364 49364 /* end confdefs.h. */
49365 49365 int i;
49366 49366 _ACEOF
49367 49367 if ac_fn_c_try_compile "$LINENO"; then :
49368 49368
49369 49369 else
49370 49370 supports=no
49371 49371 fi
49372 49372 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
49373 49373 ac_ext=cpp
49374 49374 ac_cpp='$CXXCPP $CPPFLAGS'
49375 49375 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49376 49376 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49377 49377 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
49378 49378
49379 49379 CFLAGS="$saved_cflags"
49380 49380
49381 49381 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
49382 49382 $as_echo "$supports" >&6; }
49383 49383 if test "x$supports" = "xyes" ; then
49384 49384 :
49385 49385 C_COMP_SUPPORTS="yes"
49386 49386 else
49387 49387 :
49388 49388 C_COMP_SUPPORTS="no"
49389 49389 fi
49390 49390
49391 49391
49392 49392
49393 49393
49394 49394
49395 49395
49396 49396
49397 49397
49398 49398
49399 49399
49400 49400
49401 49401
49402 49402
49403 49403
49404 49404
49405 49405
49406 49406
49407 49407
49408 49408
49409 49409
49410 49410
49411 49411
49412 49412
49413 49413
49414 49414
49415 49415
49416 49416
49417 49417
49418 49418
49419 49419
49420 49420
49421 49421
49422 49422
49423 49423
49424 49424
49425 49425
49426 49426
49427 49427
49428 49428
49429 49429
49430 49430
49431 49431
49432 49432
49433 49433
49434 49434
49435 49435
49436 49436
49437 49437
49438 49438
49439 49439
49440 49440
49441 49441
49442 49442
49443 49443
49444 49444
49445 49445
49446 49446
49447 49447
49448 49448
49449 49449 # Execute function body
49450 49450
49451 49451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
49452 49452 $as_echo_n "checking if the C++ compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
49453 49453 supports=yes
49454 49454
49455 49455 saved_cxxflags="$CXXFLAGS"
49456 49456 CXXFLAGS="$CXXFLAG $STACK_PROTECTOR_CFLAG -Werror"
49457 49457 ac_ext=cpp
49458 49458 ac_cpp='$CXXCPP $CPPFLAGS'
49459 49459 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49460 49460 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49461 49461 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
49462 49462
49463 49463 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
49464 49464 /* end confdefs.h. */
49465 49465 int i;
49466 49466 _ACEOF
49467 49467 if ac_fn_cxx_try_compile "$LINENO"; then :
49468 49468
49469 49469 else
49470 49470 supports=no
49471 49471 fi
49472 49472 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
49473 49473 ac_ext=cpp
49474 49474 ac_cpp='$CXXCPP $CPPFLAGS'
49475 49475 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49476 49476 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49477 49477 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
49478 49478
49479 49479 CXXFLAGS="$saved_cxxflags"
49480 49480
49481 49481 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
49482 49482 $as_echo "$supports" >&6; }
49483 49483 if test "x$supports" = "xyes" ; then
49484 49484 :
49485 49485 CXX_COMP_SUPPORTS="yes"
49486 49486 else
49487 49487 :
49488 49488 CXX_COMP_SUPPORTS="no"
49489 49489 fi
49490 49490
49491 49491
49492 49492
49493 49493
49494 49494
49495 49495
49496 49496
49497 49497
49498 49498
49499 49499
49500 49500
49501 49501
49502 49502
49503 49503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
49504 49504 $as_echo_n "checking if both compilers support \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
49505 49505 supports=no
49506 49506 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
49507 49507
49508 49508 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
49509 49509 $as_echo "$supports" >&6; }
49510 49510 if test "x$supports" = "xyes" ; then
49511 49511 :
49512 49512
49513 49513 else
49514 49514 :
49515 49515 STACK_PROTECTOR_CFLAG=""
49516 49516 fi
49517 49517
49518 49518
49519 49519
49520 49520
49521 49521
49522 49522
49523 49523
49524 49524 CFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
49525 49525 CXXFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
49526 49526 if test "x$STACK_PROTECTOR_CFLAG" != x; then
49527 49527 JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
49528 49528 fi
49529 49529 ;;
49530 49530 esac
49531 49531 fi
49532 49532
49533 49533 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49534 49534 if test "x$DEBUG_LEVEL" != xrelease; then
49535 49535 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
49536 49536 JVM_CFLAGS="$JVM_CFLAGS -homeparams"
49537 49537 fi
49538 49538 fi
49539 49539 fi
49540 49540
49541 49541 # Optimization levels
49542 49542 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49543 49543 CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
49544 49544
49545 49545 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
49546 49546 # FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global?
49547 49547 C_O_FLAG_HIGHEST_JVM="-xO4"
49548 49548 C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
49549 49549 C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
49550 49550 C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
49551 49551 C_O_FLAG_DEBUG="-xregs=no%frameptr"
49552 49552 C_O_FLAG_DEBUG_JVM=""
49553 49553 C_O_FLAG_NONE="-xregs=no%frameptr"
49554 49554 CXX_O_FLAG_HIGHEST_JVM="-xO4"
49555 49555 CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
49556 49556 CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
49557 49557 CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
49558 49558 CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
49559 49559 CXX_O_FLAG_DEBUG_JVM=""
49560 49560 CXX_O_FLAG_NONE="-xregs=no%frameptr"
49561 49561 if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
49562 49562 C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
49563 49563 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
49564 49564 fi
49565 49565 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
49566 49566 C_O_FLAG_HIGHEST_JVM="-xO4"
49567 49567 C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
49568 49568 C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
49569 49569 C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
49570 49570 C_O_FLAG_DEBUG=""
49571 49571 C_O_FLAG_DEBUG_JVM=""
49572 49572 C_O_FLAG_NONE=""
49573 49573 CXX_O_FLAG_HIGHEST_JVM="-xO4"
49574 49574 CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
49575 49575 CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
49576 49576 CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
49577 49577 CXX_O_FLAG_DEBUG=""
49578 49578 CXX_O_FLAG_DEBUG_JVM=""
49579 49579 CXX_O_FLAG_NONE=""
49580 49580 fi
49581 49581 else
49582 49582 # The remaining toolchains share opt flags between CC and CXX;
49583 49583 # setup for C and duplicate afterwards.
49584 49584 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49585 49585 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49586 49586 # On MacOSX we optimize for size, something
49587 49587 # we should do for all platforms?
49588 49588 C_O_FLAG_HIGHEST_JVM="-Os"
49589 49589 C_O_FLAG_HIGHEST="-Os"
49590 49590 C_O_FLAG_HI="-Os"
49591 49591 C_O_FLAG_NORM="-Os"
49592 49592 C_O_FLAG_SIZE="-Os"
49593 49593 else
49594 49594 C_O_FLAG_HIGHEST_JVM="-O3"
49595 49595 C_O_FLAG_HIGHEST="-O3"
49596 49596 C_O_FLAG_HI="-O3"
49597 49597 C_O_FLAG_NORM="-O2"
49598 49598 C_O_FLAG_SIZE="-Os"
49599 49599 fi
49600 49600 C_O_FLAG_DEBUG="-O0"
49601 49601 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49602 49602 C_O_FLAG_DEBUG_JVM=""
49603 49603 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
49604 49604 C_O_FLAG_DEBUG_JVM="-O0"
49605 49605 fi
49606 49606 C_O_FLAG_NONE="-O0"
49607 49607 elif test "x$TOOLCHAIN_TYPE" = xclang; then
49608 49608 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49609 49609 # On MacOSX we optimize for size, something
49610 49610 # we should do for all platforms?
49611 49611 C_O_FLAG_HIGHEST_JVM="-Os"
49612 49612 C_O_FLAG_HIGHEST="-Os"
49613 49613 C_O_FLAG_HI="-Os"
49614 49614 C_O_FLAG_NORM="-Os"
49615 49615 C_O_FLAG_SIZE="-Os"
49616 49616 else
49617 49617 C_O_FLAG_HIGHEST_JVM="-O3"
49618 49618 C_O_FLAG_HIGHEST="-O3"
49619 49619 C_O_FLAG_HI="-O3"
49620 49620 C_O_FLAG_NORM="-O2"
49621 49621 C_O_FLAG_SIZE="-Os"
49622 49622 fi
49623 49623 C_O_FLAG_DEBUG="-O0"
49624 49624 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
49625 49625 C_O_FLAG_DEBUG_JVM=""
49626 49626 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
49627 49627 C_O_FLAG_DEBUG_JVM="-O0"
49628 49628 fi
49629 49629 C_O_FLAG_NONE="-O0"
49630 49630 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
49631 49631 C_O_FLAG_HIGHEST_JVM="-O3 -qhot=level=1 -qinline -qinlglue"
49632 49632 C_O_FLAG_HIGHEST="-O3 -qhot=level=1 -qinline -qinlglue"
49633 49633 C_O_FLAG_HI="-O3 -qinline -qinlglue"
49634 49634 C_O_FLAG_NORM="-O2"
49635 49635 C_O_FLAG_DEBUG="-qnoopt"
49636 49636 # FIXME: Value below not verified.
49637 49637 C_O_FLAG_DEBUG_JVM=""
49638 49638 C_O_FLAG_NONE="-qnoopt"
49639 49639 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
49640 49640 C_O_FLAG_HIGHEST_JVM="-O2 -Oy-"
49641 49641 C_O_FLAG_HIGHEST="-O2"
49642 49642 C_O_FLAG_HI="-O1"
49643 49643 C_O_FLAG_NORM="-O1"
49644 49644 C_O_FLAG_DEBUG="-Od"
49645 49645 C_O_FLAG_DEBUG_JVM=""
49646 49646 C_O_FLAG_NONE="-Od"
49647 49647 C_O_FLAG_SIZE="-Os"
49648 49648 fi
49649 49649 CXX_O_FLAG_HIGHEST_JVM="$C_O_FLAG_HIGHEST_JVM"
49650 49650 CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
49651 49651 CXX_O_FLAG_HI="$C_O_FLAG_HI"
49652 49652 CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
49653 49653 CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
49654 49654 CXX_O_FLAG_DEBUG_JVM="$C_O_FLAG_DEBUG_JVM"
49655 49655 CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
49656 49656 CXX_O_FLAG_SIZE="$C_O_FLAG_SIZE"
49657 49657 fi
49658 49658
49659 49659 # Adjust optimization flags according to debug level.
49660 49660 case $DEBUG_LEVEL in
49661 49661 release )
49662 49662 # no adjustment
49663 49663 ;;
49664 49664 fastdebug )
49665 49665 # Not quite so much optimization
49666 49666 C_O_FLAG_HI="$C_O_FLAG_NORM"
49667 49667 CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
49668 49668 ;;
49669 49669 slowdebug )
49670 49670 # Disable optimization
49671 49671 C_O_FLAG_HIGHEST_JVM="$C_O_FLAG_DEBUG_JVM"
49672 49672 C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
49673 49673 C_O_FLAG_HI="$C_O_FLAG_DEBUG"
49674 49674 C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
49675 49675 C_O_FLAG_SIZE="$C_O_FLAG_DEBUG"
49676 49676 CXX_O_FLAG_HIGHEST_JVM="$CXX_O_FLAG_DEBUG_JVM"
49677 49677 CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
49678 49678 CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
49679 49679 CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
49680 49680 CXX_O_FLAG_SIZE="$CXX_O_FLAG_DEBUG"
49681 49681 ;;
49682 49682 esac
49683 49683
49684 49684
49685 49685
49686 49686
49687 49687
49688 49688
49689 49689
49690 49690
49691 49691
49692 49692
49693 49693
49694 49694
49695 49695
49696 49696
49697 49697
49698 49698
49699 49699
49700 49700
49701 49701
49702 49702 # Special extras...
49703 49703 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49704 49704 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
49705 49705 CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
49706 49706 CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
49707 49707 fi
49708 49708 CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
49709 49709 CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
49710 49710 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
49711 49711 CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
49712 49712 CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
49713 49713 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
49714 49714 CXXSTD_CXXFLAG="-std=gnu++98"
49715 49715
49716 49716
49717 49717
49718 49718
49719 49719
49720 49720
49721 49721
49722 49722
49723 49723
49724 49724
49725 49725
49726 49726
49727 49727
49728 49728
49729 49729
49730 49730
49731 49731
49732 49732
49733 49733
49734 49734
49735 49735
49736 49736
49737 49737
49738 49738
49739 49739
49740 49740
49741 49741
49742 49742
49743 49743
49744 49744
49745 49745
49746 49746
49747 49747
49748 49748
49749 49749
49750 49750
49751 49751
49752 49752
49753 49753
49754 49754
49755 49755
49756 49756
49757 49757 # Execute function body
49758 49758
49759 49759 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
49760 49760 $as_echo_n "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
49761 49761 supports=yes
49762 49762
49763 49763 saved_cxxflags="$CXXFLAGS"
49764 49764 CXXFLAGS="$CXXFLAG $CXXSTD_CXXFLAG -Werror"
49765 49765 ac_ext=cpp
49766 49766 ac_cpp='$CXXCPP $CPPFLAGS'
49767 49767 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49768 49768 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49769 49769 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
49770 49770
49771 49771 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
49772 49772 /* end confdefs.h. */
49773 49773 int i;
49774 49774 _ACEOF
49775 49775 if ac_fn_cxx_try_compile "$LINENO"; then :
49776 49776
49777 49777 else
49778 49778 supports=no
49779 49779 fi
49780 49780 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
49781 49781 ac_ext=cpp
49782 49782 ac_cpp='$CXXCPP $CPPFLAGS'
49783 49783 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
49784 49784 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
49785 49785 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
49786 49786
49787 49787 CXXFLAGS="$saved_cxxflags"
49788 49788
49789 49789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
49790 49790 $as_echo "$supports" >&6; }
49791 49791 if test "x$supports" = "xyes" ; then
49792 49792 :
49793 49793
49794 49794 else
49795 49795 :
49796 49796 CXXSTD_CXXFLAG=""
49797 49797 fi
49798 49798
49799 49799
49800 49800
49801 49801
49802 49802
49803 49803
49804 49804
49805 49805
49806 49806
49807 49807
49808 49808
49809 49809
49810 49810 CXXFLAGS_JDK="${CXXFLAGS_JDK} ${CXXSTD_CXXFLAG}"
49811 49811 JVM_CFLAGS="${JVM_CFLAGS} ${CXXSTD_CXXFLAG}"
49812 49812
49813 49813 fi
49814 49814 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
49815 49815 CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
49816 49816 CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
49817 49817 fi
49818 49818
49819 49819 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
49820 49820 CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
49821 49821 CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
49822 49822 fi
49823 49823
49824 49824 CFLAGS_JDK="${CFLAGS_JDK} ${EXTRA_CFLAGS}"
49825 49825 CXXFLAGS_JDK="${CXXFLAGS_JDK} ${EXTRA_CXXFLAGS}"
49826 49826 LDFLAGS_JDK="${LDFLAGS_JDK} ${EXTRA_LDFLAGS}"
49827 49827
49828 49828 ###############################################################################
49829 49829 #
49830 49830 # Now setup the CFLAGS and LDFLAGS for the JDK build.
49831 49831 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
49832 49832 #
49833 49833
49834 49834 # Setup compiler/platform specific flags into
49835 49835 # CFLAGS_JDK - C Compiler flags
49836 49836 # CXXFLAGS_JDK - C++ Compiler flags
49837 49837 # COMMON_CCXXFLAGS_JDK - common to C and C++
49838 49838 if test "x$TOOLCHAIN_TYPE" = xgcc; then
49839 49839 JVM_CFLAGS="$JVM_CFLAGS -D_GNU_SOURCE"
49840 49840 JVM_CFLAGS="$JVM_CFLAGS -D_REENTRANT"
49841 49841 JVM_CFLAGS="$JVM_CFLAGS -fcheck-new"
49842 49842 if test "x$OPENJDK_TARGET_CPU" = xx86; then
49843 49843 # Force compatibility with i586 on 32 bit intel platforms.
49844 49844 COMMON_CCXXFLAGS="${COMMON_CCXXFLAGS} -march=i586"
49845 49845 JVM_CFLAGS="$JVM_CFLAGS -march=i586"
49846 49846 fi
49847 49847 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
49848 49848 -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
49849 49849 case $OPENJDK_TARGET_CPU_ARCH in
49850 49850 arm )
49851 49851 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
49852 49852 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
49853 49853 ;;
49854 49854 ppc )
49855 49855 # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
49856 49856 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
49857 49857 ;;
49858 49858 * )
49859 49859 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
49860 49860 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
49861 49861 ;;
49862 49862 esac
49863 49863
49864 49864
49865 49865
49866 49866
49867 49867
49868 49868
49869 49869
49870 49870
49871 49871
49872 49872
49873 49873
49874 49874
49875 49875
49876 49876
49877 49877
49878 49878
49879 49879
49880 49880
49881 49881
49882 49882
49883 49883
49884 49884
49885 49885
49886 49886
49887 49887
49888 49888
49889 49889
49890 49890
49891 49891
49892 49892
49893 49893
49894 49894
49895 49895
49896 49896
49897 49897
49898 49898
49899 49899
49900 49900
49901 49901
49902 49902
49903 49903
49904 49904
49905 49905
49906 49906
49907 49907
49908 49908
49909 49909
49910 49910
49911 49911
49912 49912
49913 49913
49914 49914
49915 49915
49916 49916
49917 49917 # Execute function body
49918 49918
49919 49919 # Need to assign to a variable since m4 is blocked from modifying parts in [].
49920 49920 REFERENCE_VERSION=6
49921 49921
49922 49922 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
49923 49923 as_fn_error $? "Internal error: Cannot compare to 6, only three parts (X.Y.Z) is supported" "$LINENO" 5
49924 49924 fi
49925 49925
49926 49926 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
49927 49927 as_fn_error $? "Internal error: Cannot compare to 6, only parts < 99999 is supported" "$LINENO" 5
49928 49928 fi
49929 49929
49930 49930 # Version comparison method inspired by http://stackoverflow.com/a/24067243
49931 49931 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
49932 49932
49933 49933 if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
49934 49934 :
49935 49935
49936 49936 # These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
49937 49937 # runs afoul of the more aggressive versions of these optimisations.
49938 49938 # Notably, value range propagation now assumes that the this pointer of C++
49939 49939 # member functions is non-null.
49940 49940 NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
49941 49941 NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
49942 49942 { $as_echo "$as_me:${as_lineno-$LINENO}: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&5
49943 49943 $as_echo "$as_me: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&6;}
49944 49944 CFLAGS_JDK="$CFLAGS_JDK ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
49945 49945 JVM_CFLAGS="$JVM_CFLAGS ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
49946 49946
49947 49947 else
49948 49948 :
49949 49949
49950 49950 fi
49951 49951
49952 49952
49953 49953
49954 49954
49955 49955
49956 49956
49957 49957
49958 49958
49959 49959
49960 49960
49961 49961
49962 49962
49963 49963
49964 49964
49965 49965 elif test "x$TOOLCHAIN_TYPE" = xclang; then
49966 49966 JVM_CFLAGS="$JVM_CFLAGS -D_GNU_SOURCE"
49967 49967
49968 49968 # Restrict the debug information created by Clang to avoid
49969 49969 # too big object files and speed the build up a little bit
49970 49970 # (see http://llvm.org/bugs/show_bug.cgi?id=7554)
49971 49971 JVM_CFLAGS="$JVM_CFLAGS -flimit-debug-info"
49972 49972 if test "x$OPENJDK_TARGET_OS" = xlinux; then
49973 49973 if test "x$OPENJDK_TARGET_CPU" = xx86; then
49974 49974 # Force compatibility with i586 on 32 bit intel platforms.
49975 49975 COMMON_CCXXFLAGS="${COMMON_CCXXFLAGS} -march=i586"
49976 49976 JVM_CFLAGS="$JVM_CFLAGS -march=i586"
49977 49977 fi
49978 49978 JVM_CFLAGS="$JVM_CFLAGS -Wno-sometimes-uninitialized"
49979 49979 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
49980 49980 -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
49981 49981 case $OPENJDK_TARGET_CPU_ARCH in
49982 49982 ppc )
49983 49983 # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
49984 49984 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
49985 49985 ;;
49986 49986 * )
49987 49987 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
49988 49988 CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
49989 49989 ;;
49990 49990 esac
49991 49991 fi
49992 49992 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
49993 49993 JVM_CFLAGS="$JVM_CFLAGS -DSPARC_WORKS"
49994 49994 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
49995 49995 if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
49996 49996 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
49997 49997 fi
49998 49998
49999 49999 CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
50000 50000 CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
50001 50001 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
50002 50002 JVM_CFLAGS="$JVM_CFLAGS -D_REENTRANT -D__STDC_FORMAT_MACROS"
50003 50003 CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
50004 50004 CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
50005 50005 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
50006 50006 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK \
50007 50007 -MD -Zc:wchar_t- -W3 -wd4800 \
50008 50008 -DWIN32_LEAN_AND_MEAN \
50009 50009 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
50010 50010 -D_WINSOCK_DEPRECATED_NO_WARNINGS \
50011 50011 -DWIN32 -DIAL"
50012 50012 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
50013 50013 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
50014 50014 else
50015 50015 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
50016 50016 fi
50017 50017 # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
50018 50018 # avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
50019 50019 # studio.
50020 50020 if test "x$TOOLCHAIN_VERSION" = "x2010"; then
50021 50021 STATIC_CPPLIB_FLAGS="-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
50022 50022 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $STATIC_CPPLIB_FLAGS"
50023 50023 JVM_CFLAGS="$JVM_CFLAGS $STATIC_CPPLIB_FLAGS"
50024 50024 fi
50025 50025 fi
50026 50026
50027 50027 ###############################################################################
50028 50028
50029 50029 # Adjust flags according to debug level.
50030 50030 case $DEBUG_LEVEL in
50031 50031 fastdebug | slowdebug )
50032 50032 CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
50033 50033 CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
50034 50034 JAVAC_FLAGS="$JAVAC_FLAGS -g"
50035 50035 ;;
50036 50036 release )
50037 50037 ;;
50038 50038 * )
50039 50039 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
50040 50040 ;;
50041 50041 esac
50042 50042
50043 50043 # Set some common defines. These works for all compilers, but assume
50044 50044 # -D is universally accepted.
50045 50045
50046 50046 # Setup endianness
50047 50047 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
50048 50048 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
50049 50049 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
50050 50050 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
50051 50051 # Note: -Dmacro is the same as #define macro 1
50052 50052 # -Dmacro= is the same as #define macro
50053 50053 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
50054 50054 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
50055 50055 else
50056 50056 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
50057 50057 fi
50058 50058 else
50059 50059 # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
50060 50060 # are defined in the system?
50061 50061 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
50062 50062 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
50063 50063 else
50064 50064 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
50065 50065 fi
50066 50066 fi
50067 50067
50068 50068 # Setup target OS define. Use OS target name but in upper case.
50069 50069 OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
50070 50070 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
50071 50071
50072 50072 # Setup target CPU
50073 50073 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
50074 50074 $OPENJDK_TARGET_ADD_LP64 \
50075 50075 -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
50076 50076
50077 50077 # Setup debug/release defines
50078 50078 if test "x$DEBUG_LEVEL" = xrelease; then
50079 50079 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
50080 50080 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
50081 50081 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
50082 50082 fi
50083 50083 else
50084 50084 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
50085 50085 fi
50086 50086
50087 50087 # Set some additional per-OS defines.
50088 50088 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50089 50089 JVM_CFLAGS="$JVM_CFLAGS -DLINUX"
50090 50090 JVM_CFLAGS="$JVM_CFLAGS -pipe -fPIC -fno-rtti -fno-exceptions \
50091 50091 -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
50092 50092 elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
50093 50093 JVM_CFLAGS="$JVM_CFLAGS -DSOLARIS"
50094 50094 JVM_CFLAGS="$JVM_CFLAGS -template=no%extdef -features=no%split_init \
50095 50095 -D_Crun_inline_placement -library=%none -KPIC -mt -xwe -features=no%except"
50096 50096 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
50097 50097 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
50098 50098 JVM_CFLAGS="$JVM_CFLAGS -D_ALLBSD_SOURCE"
50099 50099 JVM_CFLAGS="$JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
50100 50100 JVM_CFLAGS="$JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
50101 50101 -mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
50102 50102 -DMAC_OS_X_VERSION_MAX_ALLOWED=1070 -mmacosx-version-min=10.7.0 \
50103 50103 -fno-omit-frame-pointer"
50104 50104 elif test "x$OPENJDK_TARGET_OS" = xaix; then
50105 50105 JVM_CFLAGS="$JVM_CFLAGS -DAIX"
50106 50106 # We may need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
50107 50107 JVM_CFLAGS="$JVM_CFLAGS -qtune=balanced \
50108 50108 -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
50109 50109 -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
50110 50110 elif test "x$OPENJDK_TARGET_OS" = xbsd; then
50111 50111 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
50112 50112 elif test "x$OPENJDK_TARGET_OS" = xwindows; then
50113 50113 JVM_CFLAGS="$JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
50114 50114 JVM_CFLAGS="$JVM_CFLAGS -nologo -W3 -MD -MP"
50115 50115 fi
50116 50116
50117 50117 # Set some additional per-CPU defines.
50118 50118 if test "x$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" = xwindows-x86; then
50119 50119 JVM_CFLAGS="$JVM_CFLAGS -arch:IA32"
50120 50120 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
50121 50121 JVM_CFLAGS="$JVM_CFLAGS -xarch=sparc"
50122 50122 elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
50123 50123 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50124 50124 JVM_CFLAGS="$JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
50125 50125 # fixes `relocation truncated to fit' error for gcc 4.1.
50126 50126 JVM_CFLAGS="$JVM_CFLAGS -mminimal-toc"
50127 50127 # Use ppc64 instructions, but schedule for power5
50128 50128 JVM_CFLAGS="$JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
50129 50129 elif test "x$OPENJDK_TARGET_OS" = xaix; then
50130 50130 JVM_CFLAGS="$JVM_CFLAGS -qarch=ppc64"
50131 50131 fi
50132 50132 elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
50133 50133 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50134 50134 JVM_CFLAGS="$JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
50135 50135 # Little endian machine uses ELFv2 ABI.
50136 50136 JVM_CFLAGS="$JVM_CFLAGS -DABI_ELFv2"
50137 50137 # Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
50138 50138 JVM_CFLAGS="$JVM_CFLAGS -mcpu=power7 -mtune=power8"
50139 50139 fi
50140 50140 fi
50141 50141
50142 50142 if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
50143 50143 JVM_CFLAGS="$JVM_CFLAGS -DVM_LITTLE_ENDIAN"
50144 50144 fi
50145 50145
50146 50146 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50147 50147 if test "x$OPENJDK_TARGET_OS" != xsolaris && test "x$OPENJDK_TARGET_OS" != xaix; then
50148 50148 # Solaris does not have _LP64=1 in the old build.
50149 50149 # xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
50150 50150 JVM_CFLAGS="$JVM_CFLAGS -D_LP64=1"
50151 50151 fi
50152 50152 fi
50153 50153
50154 50154 # Set JVM_CFLAGS warning handling
50155 50155 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50156 50156 JVM_CFLAGS="$JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
50157 50157 -Wunused-value -Woverloaded-virtual"
50158 50158
50159 50159 if test "x$TOOLCHAIN_TYPE" = xgcc; then
50160 50160
50161 50161
50162 50162
50163 50163
50164 50164
50165 50165
50166 50166
50167 50167
50168 50168
50169 50169
50170 50170
50171 50171
50172 50172
50173 50173
50174 50174
50175 50175
50176 50176
50177 50177
50178 50178
50179 50179
50180 50180
50181 50181
50182 50182
50183 50183
50184 50184
50185 50185
50186 50186
50187 50187
50188 50188
50189 50189
50190 50190
50191 50191
50192 50192
50193 50193
50194 50194
50195 50195
50196 50196
50197 50197
50198 50198
50199 50199
50200 50200
50201 50201
50202 50202
50203 50203
50204 50204
50205 50205
50206 50206
50207 50207
50208 50208
50209 50209
50210 50210
50211 50211
50212 50212
50213 50213
50214 50214 # Execute function body
50215 50215
50216 50216 # Need to assign to a variable since m4 is blocked from modifying parts in [].
50217 50217 REFERENCE_VERSION=4.8
50218 50218
50219 50219 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
50220 50220 as_fn_error $? "Internal error: Cannot compare to 4.8, only three parts (X.Y.Z) is supported" "$LINENO" 5
50221 50221 fi
50222 50222
50223 50223 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
50224 50224 as_fn_error $? "Internal error: Cannot compare to 4.8, only parts < 99999 is supported" "$LINENO" 5
50225 50225 fi
50226 50226
50227 50227 # Version comparison method inspired by http://stackoverflow.com/a/24067243
50228 50228 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
50229 50229
50230 50230 if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
50231 50231 :
50232 50232
50233 50233 # These flags either do not work or give spurious warnings prior to gcc 4.8.
50234 50234 JVM_CFLAGS="$JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
50235 50235
50236 50236
50237 50237 else
50238 50238 :
50239 50239
50240 50240 fi
50241 50241
50242 50242
50243 50243
50244 50244
50245 50245
50246 50246
50247 50247
50248 50248
50249 50249
50250 50250
50251 50251
50252 50252
50253 50253
50254 50254
50255 50255 fi
50256 50256 if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
50257 50257 # Non-zero builds have stricter warnings
50258 50258 JVM_CFLAGS="$JVM_CFLAGS -Wreturn-type -Wundef -Wformat=2"
50259 50259 else
50260 50260 if test "x$TOOLCHAIN_TYPE" = xclang; then
50261 50261 # Some versions of llvm do not like -Wundef
50262 50262 JVM_CFLAGS="$JVM_CFLAGS -Wno-undef"
50263 50263 fi
50264 50264 fi
50265 50265 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
50266 50266 JVM_CFLAGS="$JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
50267 50267 -Wsign-compare -Wundef -Wunused-function -Wformat=2"
50268 50268 fi
50269 50269
50270 50270 # Additional macosx handling
50271 50271 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
50272 50272 # Setting these parameters makes it an error to link to macosx APIs that are
50273 50273 # newer than the given OS version and makes the linked binaries compatible
50274 50274 # even if built on a newer version of the OS.
50275 50275 # The expected format is X.Y.Z
50276 50276 MACOSX_VERSION_MIN=10.7.0
50277 50277
50278 50278
50279 50279 # The macro takes the version with no dots, ex: 1070
50280 50280 # Let the flags variables get resolved in make for easier override on make
50281 50281 # command line.
50282 50282 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
50283 50283 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
50284 50284 fi
50285 50285
50286 50286 # Setup some hard coded includes
50287 50287 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
50288 50288 -I${JDK_TOPDIR}/src/java.base/share/native/include \
50289 50289 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \
50290 50290 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/include \
50291 50291 -I${JDK_TOPDIR}/src/java.base/share/native/libjava \
50292 50292 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/libjava"
50293 50293
50294 50294 # The shared libraries are compiled using the picflag.
50295 50295 CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK \
50296 50296 $CFLAGS_JDK $EXTRA_CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
50297 50297 CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK \
50298 50298 $CXXFLAGS_JDK $EXTRA_CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"
50299 50299
50300 50300 # Executable flags
50301 50301 CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $EXTRA_CFLAGS_JDK"
50302 50302 CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $EXTRA_CXXFLAGS_JDK"
50303 50303
50304 50304
50305 50305
50306 50306
50307 50307
50308 50308
50309 50309 # Setup LDFLAGS et al.
50310 50310 #
50311 50311
50312 50312 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
50313 50313 LDFLAGS_MICROSOFT="-nologo -opt:ref"
50314 50314 LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
50315 50315 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
50316 50316 if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
50317 50317 LDFLAGS_SAFESH="-safeseh"
50318 50318 LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_SAFESH"
50319 50319 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_SAFESH"
50320 50320 # NOTE: Old build added -machine. Probably not needed.
50321 50321 JVM_LDFLAGS="$JVM_LDFLAGS -machine:I386"
50322 50322 else
50323 50323 JVM_LDFLAGS="$JVM_LDFLAGS -machine:AMD64"
50324 50324 fi
50325 50325 elif test "x$TOOLCHAIN_TYPE" = xclang; then
50326 50326 JVM_LDFLAGS="$JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
50327 50327 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
50328 50328 # FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
50329 50329 JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
50330 50330 fi
50331 50331 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
50332 50332 # If this is a --hash-style=gnu system, use --hash-style=both, why?
50333 50333 # We have previously set HAS_GNU_HASH if this is the case
50334 50334 if test -n "$HAS_GNU_HASH"; then
50335 50335 LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
50336 50336 LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_HASH_STYLE"
50337 50337 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_HASH_STYLE"
50338 50338 fi
50339 50339 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
50340 50340 JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
50341 50341 fi
50342 50342 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50343 50343 # And since we now know that the linker is gnu, then add -z defs, to forbid
50344 50344 # undefined symbols in object files.
50345 50345 LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
50346 50346 LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
50347 50347 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_NO_UNDEF_SYM"
50348 50348 LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
50349 50349 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
50350 50350 if test "x$OPENJDK_TARGET_CPU" = xx86; then
50351 50351 JVM_LDFLAGS="$JVM_LDFLAGS -march=i586"
50352 50352 fi
50353 50353 case $DEBUG_LEVEL in
50354 50354 release )
50355 50355 # tell linker to optimize libraries.
50356 50356 # Should this be supplied to the OSS linker as well?
50357 50357 LDFLAGS_DEBUGLEVEL_release="-Wl,-O1"
50358 50358 LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_DEBUGLEVEL_release"
50359 50359 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_DEBUGLEVEL_release"
50360 50360 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
50361 50361 JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
50362 50362 fi
50363 50363 ;;
50364 50364 slowdebug )
50365 50365 # Hotspot always let the linker optimize
50366 50366 JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-O1"
50367 50367 if test "x$HAS_LINKER_NOW" = "xtrue"; then
50368 50368 # do relocations at load
50369 50369 LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG"
50370 50370 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
50371 50371 JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_NOW_FLAG"
50372 50372 fi
50373 50373 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
50374 50374 # mark relocations read only
50375 50375 LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
50376 50376 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
50377 50377 JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
50378 50378 fi
50379 50379 ;;
50380 50380 fastdebug )
50381 50381 # Hotspot always let the linker optimize
50382 50382 JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-O1"
50383 50383 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
50384 50384 # mark relocations read only
50385 50385 LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
50386 50386 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
50387 50387 JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
50388 50388 fi
50389 50389 ;;
50390 50390 * )
50391 50391 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
50392 50392 ;;
50393 50393 esac
50394 50394 fi
50395 50395 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
50396 50396 LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
50397 50397 LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
50398 50398 LDFLAGS_CXX_SOLSTUDIO="-norunpath"
50399 50399 LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
50400 50400 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
50401 50401 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
50402 50402 JVM_LDFLAGS="$JVM_LDFLAGS -xarch=sparc"
50403 50403 fi
50404 50404 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
50405 50405 LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok"
50406 50406 LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_XLC"
50407 50407 JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_XLC"
50408 50408 fi
50409 50409
50410 50410 # Customize LDFLAGS for executables
50411 50411
50412 50412 LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
50413 50413
50414 50414 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
50415 50415 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
50416 50416 LDFLAGS_STACK_SIZE=1048576
50417 50417 else
50418 50418 LDFLAGS_STACK_SIZE=327680
50419 50419 fi
50420 50420 LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
50421 50421 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
50422 50422 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
50423 50423 fi
50424 50424
50425 50425 LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} ${EXTRA_LDFLAGS_JDK}"
50426 50426
50427 50427 # Customize LDFLAGS for libs
50428 50428 LDFLAGS_JDKLIB="${LDFLAGS_JDK}"
50429 50429
50430 50430 LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS}"
50431 50431 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
50432 50432 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
50433 50433 -libpath:${OUTPUT_ROOT}/support/modules_libs/java.base"
50434 50434 JDKLIB_LIBS=""
50435 50435 else
50436 50436 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
50437 50437 -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)"
50438 50438
50439 50439 if test "xTARGET" = "xTARGET"; then
50440 50440 # On some platforms (mac) the linker warns about non existing -L dirs.
50441 50441 # Add server first if available. Linking aginst client does not always produce the same results.
50442 50442 # Only add client/minimal dir if client/minimal is being built.
50443 50443 # Default to server for other variants.
50444 50444 if [[ " $JVM_VARIANTS " =~ " server " ]] ; then
50445 50445 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)/server"
50446 50446 elif [[ " $JVM_VARIANTS " =~ " client " ]] ; then
50447 50447 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)/client"
50448 50448 elif [[ " $JVM_VARIANTS " =~ " minimal " ]] ; then
50449 50449 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)/minimal"
50450 50450 else
50451 50451 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)/server"
50452 50452 fi
50453 50453 elif test "xTARGET" = "xBUILD"; then
50454 50454 # When building a buildjdk, it's always only the server variant
50455 50455 JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
50456 50456 -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_TARGET_CPU_LIBDIR)/server"
50457 50457 fi
50458 50458
50459 50459 JDKLIB_LIBS="-ljava -ljvm"
50460 50460 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
50461 50461 JDKLIB_LIBS="$JDKLIB_LIBS -lc"
50462 50462 fi
50463 50463
50464 50464 fi
50465 50465
50466 50466 LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${JAVA_BASE_LDFLAGS}"
50467 50467
50468 50468 # Set JVM_LIBS (per os)
50469 50469 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50470 50470 JVM_LIBS="$JVM_LIBS -lm -ldl -lpthread"
50471 50471 elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
50472 50472 # FIXME: This hard-coded path is not really proper.
50473 50473 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
50474 50474 SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
50475 50475 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
50476 50476 SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
50477 50477 fi
50478 50478 JVM_LIBS="$JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
50479 50479 -lthread -ldoor -lc -ldemangle -lnsl -lkstat -lrt"
50480 50480 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
50481 50481 JVM_LIBS="$JVM_LIBS -lm"
50482 50482 elif test "x$OPENJDK_TARGET_OS" = xaix; then
50483 50483 JVM_LIBS="$JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
50484 50484 elif test "x$OPENJDK_TARGET_OS" = xbsd; then
50485 50485 JVM_LIBS="$JVM_LIBS -lm"
50486 50486 elif test "x$OPENJDK_TARGET_OS" = xwindows; then
50487 50487 JVM_LIBS="$JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
50488 50488 comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
50489 50489 wsock32.lib winmm.lib version.lib psapi.lib"
50490 50490 fi
50491 50491
50492 50492 # Set JVM_ASFLAGS
50493 50493 if test "x$OPENJDK_TARGET_OS" = xlinux; then
50494 50494 if test "x$OPENJDK_TARGET_CPU" = xx86; then
50495 50495 JVM_ASFLAGS="$JVM_ASFLAGS -march=i586"
50496 50496 fi
50497 50497 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
50498 50498 JVM_ASFLAGS="$JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
50499 50499 fi
50500 50500
50501 50501 LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${EXTRA_LDFLAGS_JDK}"
50502 50502
50503 50503
50504 50504
50505 50505
50506 50506
50507 50507
50508 50508
50509 50509
50510 50510
50511 50511
50512 50512
50513 50513
50514 50514
50515 50515
50516 50516
50517 50517 # Special extras...
50518 50518 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
50519 50519 if test "x$OPENJDK_BUILD_CPU_ARCH" = "xsparc"; then
50520 50520 OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
50521 50521 OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
50522 50522 fi
50523 50523 OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
50524 50524 OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
50525 50525 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
50526 50526 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
50527 50527 OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
50528 50528 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
50529 50529 OPENJDK_BUILD_CXXSTD_CXXFLAG="-std=gnu++98"
50530 50530
50531 50531
50532 50532
50533 50533
50534 50534
50535 50535
50536 50536
50537 50537
50538 50538
50539 50539
50540 50540
50541 50541
50542 50542
50543 50543
50544 50544
50545 50545
50546 50546
50547 50547
50548 50548
50549 50549
50550 50550
50551 50551
50552 50552
50553 50553
50554 50554
50555 50555
50556 50556
50557 50557
50558 50558
50559 50559
50560 50560
50561 50561
50562 50562
50563 50563
50564 50564
50565 50565
50566 50566
50567 50567
50568 50568
50569 50569
50570 50570
50571 50571
50572 50572 # Execute function body
50573 50573
50574 50574 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror\"" >&5
50575 50575 $as_echo_n "checking if the C++ compiler supports \"$OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror\"... " >&6; }
50576 50576 supports=yes
50577 50577
50578 50578 saved_cxxflags="$CXXFLAGS"
50579 50579 CXXFLAGS="$CXXFLAG $OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror"
50580 50580 ac_ext=cpp
50581 50581 ac_cpp='$CXXCPP $CPPFLAGS'
50582 50582 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
50583 50583 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
50584 50584 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
50585 50585
50586 50586 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
50587 50587 /* end confdefs.h. */
50588 50588 int i;
50589 50589 _ACEOF
50590 50590 if ac_fn_cxx_try_compile "$LINENO"; then :
50591 50591
50592 50592 else
50593 50593 supports=no
50594 50594 fi
50595 50595 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
50596 50596 ac_ext=cpp
50597 50597 ac_cpp='$CXXCPP $CPPFLAGS'
50598 50598 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
50599 50599 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
50600 50600 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
50601 50601
50602 50602 CXXFLAGS="$saved_cxxflags"
50603 50603
50604 50604 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
50605 50605 $as_echo "$supports" >&6; }
50606 50606 if test "x$supports" = "xyes" ; then
50607 50607 :
50608 50608
50609 50609 else
50610 50610 :
50611 50611 OPENJDK_BUILD_CXXSTD_CXXFLAG=""
50612 50612 fi
50613 50613
50614 50614
50615 50615
50616 50616
50617 50617
50618 50618
50619 50619
50620 50620
50621 50621
50622 50622
50623 50623
50624 50624
50625 50625 OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} ${OPENJDK_BUILD_CXXSTD_CXXFLAG}"
50626 50626 OPENJDK_BUILD_JVM_CFLAGS="${OPENJDK_BUILD_JVM_CFLAGS} ${OPENJDK_BUILD_CXXSTD_CXXFLAG}"
50627 50627
50628 50628 fi
50629 50629 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
50630 50630 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -D__solaris__"
50631 50631 OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} -D__solaris__"
50632 50632 fi
50633 50633
50634 50634 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
50635 50635 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -D__solaris__"
50636 50636 OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} -D__solaris__"
50637 50637 fi
50638 50638
50639 50639 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_CFLAGS}"
50640 50640 OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_CXXFLAGS}"
50641 50641 OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_LDFLAGS}"
50642 50642
50643 50643 ###############################################################################
50644 50644 #
50645 50645 # Now setup the CFLAGS and LDFLAGS for the JDK build.
50646 50646 # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
50647 50647 #
50648 50648
50649 50649 # Setup compiler/platform specific flags into
50650 50650 # OPENJDK_BUILD_CFLAGS_JDK - C Compiler flags
50651 50651 # OPENJDK_BUILD_CXXFLAGS_JDK - C++ Compiler flags
50652 50652 # OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK - common to C and C++
50653 50653 if test "x$TOOLCHAIN_TYPE" = xgcc; then
50654 50654 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_GNU_SOURCE"
50655 50655 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_REENTRANT"
50656 50656 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -fcheck-new"
50657 50657 if test "x$OPENJDK_BUILD_CPU" = xx86; then
50658 50658 # Force compatibility with i586 on 32 bit intel platforms.
50659 50659 OPENJDK_BUILD_COMMON_CCXXFLAGS="${OPENJDK_BUILD_COMMON_CCXXFLAGS} -march=i586"
50660 50660 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -march=i586"
50661 50661 fi
50662 50662 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
50663 50663 -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
50664 50664 case $OPENJDK_BUILD_CPU_ARCH in
50665 50665 arm )
50666 50666 # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
50667 50667 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
50668 50668 ;;
50669 50669 ppc )
50670 50670 # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
50671 50671 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
50672 50672 ;;
50673 50673 * )
50674 50674 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
50675 50675 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
50676 50676 ;;
50677 50677 esac
50678 50678
50679 50679
50680 50680
50681 50681
50682 50682
50683 50683
50684 50684
50685 50685
50686 50686
50687 50687
50688 50688
50689 50689
50690 50690
50691 50691
50692 50692
50693 50693
50694 50694
50695 50695
50696 50696
50697 50697
50698 50698
50699 50699
50700 50700
50701 50701
50702 50702
50703 50703
50704 50704
50705 50705
50706 50706
50707 50707
50708 50708
50709 50709
50710 50710
50711 50711
50712 50712
50713 50713
50714 50714
50715 50715
50716 50716
50717 50717
50718 50718
50719 50719
50720 50720
50721 50721
50722 50722
50723 50723
50724 50724
50725 50725
50726 50726
50727 50727
50728 50728
50729 50729
50730 50730
50731 50731
50732 50732 # Execute function body
50733 50733
50734 50734 # Need to assign to a variable since m4 is blocked from modifying parts in [].
50735 50735 REFERENCE_VERSION=6
50736 50736
50737 50737 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
50738 50738 as_fn_error $? "Internal error: Cannot compare to 6, only three parts (X.Y.Z) is supported" "$LINENO" 5
50739 50739 fi
50740 50740
50741 50741 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
50742 50742 as_fn_error $? "Internal error: Cannot compare to 6, only parts < 99999 is supported" "$LINENO" 5
50743 50743 fi
50744 50744
50745 50745 # Version comparison method inspired by http://stackoverflow.com/a/24067243
50746 50746 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
50747 50747
50748 50748 if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
50749 50749 :
50750 50750
50751 50751 # These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
50752 50752 # runs afoul of the more aggressive versions of these optimisations.
50753 50753 # Notably, value range propagation now assumes that the this pointer of C++
50754 50754 # member functions is non-null.
50755 50755 NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
50756 50756 NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
50757 50757 { $as_echo "$as_me:${as_lineno-$LINENO}: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&5
50758 50758 $as_echo "$as_me: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&6;}
50759 50759 OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
50760 50760 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
50761 50761
50762 50762 else
50763 50763 :
50764 50764
50765 50765 fi
50766 50766
50767 50767
50768 50768
50769 50769
50770 50770
50771 50771
50772 50772
50773 50773
50774 50774
50775 50775
50776 50776
50777 50777
50778 50778
50779 50779
50780 50780 elif test "x$TOOLCHAIN_TYPE" = xclang; then
50781 50781 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_GNU_SOURCE"
50782 50782
50783 50783 # Restrict the debug information created by Clang to avoid
50784 50784 # too big object files and speed the build up a little bit
50785 50785 # (see http://llvm.org/bugs/show_bug.cgi?id=7554)
50786 50786 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -flimit-debug-info"
50787 50787 if test "x$OPENJDK_BUILD_OS" = xlinux; then
50788 50788 if test "x$OPENJDK_BUILD_CPU" = xx86; then
50789 50789 # Force compatibility with i586 on 32 bit intel platforms.
50790 50790 OPENJDK_BUILD_COMMON_CCXXFLAGS="${OPENJDK_BUILD_COMMON_CCXXFLAGS} -march=i586"
50791 50791 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -march=i586"
50792 50792 fi
50793 50793 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-sometimes-uninitialized"
50794 50794 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
50795 50795 -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
50796 50796 case $OPENJDK_BUILD_CPU_ARCH in
50797 50797 ppc )
50798 50798 # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
50799 50799 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
50800 50800 ;;
50801 50801 * )
50802 50802 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
50803 50803 OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
50804 50804 ;;
50805 50805 esac
50806 50806 fi
50807 50807 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
50808 50808 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DSPARC_WORKS"
50809 50809 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
50810 50810 if test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
50811 50811 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_BUILD_CPU_LEGACY_LIB"
50812 50812 fi
50813 50813
50814 50814 OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
50815 50815 OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
50816 50816 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
50817 50817 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_REENTRANT -D__STDC_FORMAT_MACROS"
50818 50818 OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
50819 50819 OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
50820 50820 elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
50821 50821 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
50822 50822 -MD -Zc:wchar_t- -W3 -wd4800 \
50823 50823 -DWIN32_LEAN_AND_MEAN \
50824 50824 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
50825 50825 -D_WINSOCK_DEPRECATED_NO_WARNINGS \
50826 50826 -DWIN32 -DIAL"
50827 50827 if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
50828 50828 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
50829 50829 else
50830 50830 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
50831 50831 fi
50832 50832 # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
50833 50833 # avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
50834 50834 # studio.
50835 50835 if test "x$TOOLCHAIN_VERSION" = "x2010"; then
50836 50836 STATIC_CPPLIB_FLAGS="-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
50837 50837 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $STATIC_CPPLIB_FLAGS"
50838 50838 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS $STATIC_CPPLIB_FLAGS"
50839 50839 fi
50840 50840 fi
50841 50841
50842 50842 ###############################################################################
50843 50843
50844 50844 # Adjust flags according to debug level.
50845 50845 case $DEBUG_LEVEL in
50846 50846 fastdebug | slowdebug )
50847 50847 OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
50848 50848 OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
50849 50849 JAVAC_FLAGS="$JAVAC_FLAGS -g"
50850 50850 ;;
50851 50851 release )
50852 50852 ;;
50853 50853 * )
50854 50854 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
50855 50855 ;;
50856 50856 esac
50857 50857
50858 50858 # Set some common defines. These works for all compilers, but assume
50859 50859 # -D is universally accepted.
50860 50860
50861 50861 # Setup endianness
50862 50862 if test "x$OPENJDK_BUILD_CPU_ENDIAN" = xlittle; then
50863 50863 # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
50864 50864 # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
50865 50865 # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
50866 50866 # Note: -Dmacro is the same as #define macro 1
50867 50867 # -Dmacro= is the same as #define macro
50868 50868 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
50869 50869 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
50870 50870 else
50871 50871 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
50872 50872 fi
50873 50873 else
50874 50874 # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
50875 50875 # are defined in the system?
50876 50876 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
50877 50877 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
50878 50878 else
50879 50879 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
50880 50880 fi
50881 50881 fi
50882 50882
50883 50883 # Setup target OS define. Use OS target name but in upper case.
50884 50884 OPENJDK_BUILD_OS_UPPERCASE=`$ECHO $OPENJDK_BUILD_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
50885 50885 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D$OPENJDK_BUILD_OS_UPPERCASE"
50886 50886
50887 50887 # Setup target CPU
50888 50888 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
50889 50889 $OPENJDK_BUILD_ADD_LP64 \
50890 50890 -DARCH='\"$OPENJDK_BUILD_CPU_LEGACY\"' -D$OPENJDK_BUILD_CPU_LEGACY"
50891 50891
50892 50892 # Setup debug/release defines
50893 50893 if test "x$DEBUG_LEVEL" = xrelease; then
50894 50894 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DNDEBUG"
50895 50895 if test "x$OPENJDK_BUILD_OS" = xsolaris; then
50896 50896 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DTRIMMED"
50897 50897 fi
50898 50898 else
50899 50899 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DDEBUG"
50900 50900 fi
50901 50901
50902 50902 # Set some additional per-OS defines.
50903 50903 if test "x$OPENJDK_BUILD_OS" = xlinux; then
50904 50904 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DLINUX"
50905 50905 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -pipe -fPIC -fno-rtti -fno-exceptions \
50906 50906 -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
50907 50907 elif test "x$OPENJDK_BUILD_OS" = xsolaris; then
50908 50908 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DSOLARIS"
50909 50909 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -template=no%extdef -features=no%split_init \
50910 50910 -D_Crun_inline_placement -library=%none -KPIC -mt -xwe -features=no%except"
50911 50911 elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
50912 50912 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
50913 50913 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_ALLBSD_SOURCE"
50914 50914 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
50915 50915 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
50916 50916 -mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
50917 50917 -DMAC_OS_X_VERSION_MAX_ALLOWED=1070 -mmacosx-version-min=10.7.0 \
50918 50918 -fno-omit-frame-pointer"
50919 50919 elif test "x$OPENJDK_BUILD_OS" = xaix; then
50920 50920 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DAIX"
50921 50921 # We may need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
50922 50922 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -qtune=balanced \
50923 50923 -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
50924 50924 -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
50925 50925 elif test "x$OPENJDK_BUILD_OS" = xbsd; then
50926 50926 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
50927 50927 elif test "x$OPENJDK_BUILD_OS" = xwindows; then
50928 50928 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
50929 50929 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -nologo -W3 -MD -MP"
50930 50930 fi
50931 50931
50932 50932 # Set some additional per-CPU defines.
50933 50933 if test "x$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" = xwindows-x86; then
50934 50934 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -arch:IA32"
50935 50935 elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
50936 50936 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -xarch=sparc"
50937 50937 elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
50938 50938 if test "x$OPENJDK_BUILD_OS" = xlinux; then
50939 50939 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
50940 50940 # fixes `relocation truncated to fit' error for gcc 4.1.
50941 50941 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mminimal-toc"
50942 50942 # Use ppc64 instructions, but schedule for power5
50943 50943 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
50944 50944 elif test "x$OPENJDK_BUILD_OS" = xaix; then
50945 50945 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -qarch=ppc64"
50946 50946 fi
50947 50947 elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
50948 50948 if test "x$OPENJDK_BUILD_OS" = xlinux; then
50949 50949 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
50950 50950 # Little endian machine uses ELFv2 ABI.
50951 50951 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DABI_ELFv2"
50952 50952 # Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
50953 50953 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mcpu=power7 -mtune=power8"
50954 50954 fi
50955 50955 fi
50956 50956
50957 50957 if test "x$OPENJDK_BUILD_CPU_ENDIAN" = xlittle; then
50958 50958 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DVM_LITTLE_ENDIAN"
50959 50959 fi
50960 50960
50961 50961 if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
50962 50962 if test "x$OPENJDK_BUILD_OS" != xsolaris && test "x$OPENJDK_BUILD_OS" != xaix; then
50963 50963 # Solaris does not have _LP64=1 in the old build.
50964 50964 # xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
50965 50965 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_LP64=1"
50966 50966 fi
50967 50967 fi
50968 50968
50969 50969 # Set OPENJDK_BUILD_JVM_CFLAGS warning handling
50970 50970 if test "x$OPENJDK_BUILD_OS" = xlinux; then
50971 50971 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
50972 50972 -Wunused-value -Woverloaded-virtual"
50973 50973
50974 50974 if test "x$TOOLCHAIN_TYPE" = xgcc; then
50975 50975
50976 50976
50977 50977
50978 50978
50979 50979
50980 50980
50981 50981
50982 50982
50983 50983
50984 50984
50985 50985
50986 50986
50987 50987
50988 50988
50989 50989
50990 50990
50991 50991
50992 50992
50993 50993
50994 50994
50995 50995
50996 50996
50997 50997
50998 50998
50999 50999
51000 51000
51001 51001
51002 51002
51003 51003
51004 51004
51005 51005
51006 51006
51007 51007
51008 51008
51009 51009
51010 51010
51011 51011
51012 51012
51013 51013
51014 51014
51015 51015
51016 51016
51017 51017
51018 51018
51019 51019
51020 51020
51021 51021
51022 51022
51023 51023
51024 51024
51025 51025
51026 51026
51027 51027
51028 51028
51029 51029 # Execute function body
51030 51030
51031 51031 # Need to assign to a variable since m4 is blocked from modifying parts in [].
51032 51032 REFERENCE_VERSION=4.8
51033 51033
51034 51034 if [[ "$REFERENCE_VERSION" =~ (.*\.){3} ]] ; then
51035 51035 as_fn_error $? "Internal error: Cannot compare to 4.8, only three parts (X.Y.Z) is supported" "$LINENO" 5
51036 51036 fi
51037 51037
51038 51038 if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
51039 51039 as_fn_error $? "Internal error: Cannot compare to 4.8, only parts < 99999 is supported" "$LINENO" 5
51040 51040 fi
51041 51041
51042 51042 # Version comparison method inspired by http://stackoverflow.com/a/24067243
51043 51043 COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
51044 51044
51045 51045 if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
51046 51046 :
51047 51047
51048 51048 # These flags either do not work or give spurious warnings prior to gcc 4.8.
51049 51049 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
51050 51050
51051 51051
51052 51052 else
51053 51053 :
51054 51054
51055 51055 fi
51056 51056
51057 51057
51058 51058
51059 51059
51060 51060
51061 51061
51062 51062
51063 51063
51064 51064
51065 51065
51066 51066
51067 51067
51068 51068
51069 51069
51070 51070 fi
51071 51071 if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
51072 51072 # Non-zero builds have stricter warnings
51073 51073 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wreturn-type -Wundef -Wformat=2"
51074 51074 else
51075 51075 if test "x$TOOLCHAIN_TYPE" = xclang; then
51076 51076 # Some versions of llvm do not like -Wundef
51077 51077 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-undef"
51078 51078 fi
51079 51079 fi
51080 51080 elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
51081 51081 OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
51082 51082 -Wsign-compare -Wundef -Wunused-function -Wformat=2"
51083 51083 fi
51084 51084
51085 51085 # Additional macosx handling
51086 51086 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
51087 51087 # Setting these parameters makes it an error to link to macosx APIs that are
51088 51088 # newer than the given OS version and makes the linked binaries compatible
51089 51089 # even if built on a newer version of the OS.
51090 51090 # The expected format is X.Y.Z
51091 51091 MACOSX_VERSION_MIN=10.7.0
51092 51092
51093 51093
51094 51094 # The macro takes the version with no dots, ex: 1070
51095 51095 # Let the flags variables get resolved in make for easier override on make
51096 51096 # command line.
51097 51097 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
51098 51098 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
51099 51099 fi
51100 51100
51101 51101 # Setup some hard coded includes
51102 51102 OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
51103 51103 -I${JDK_TOPDIR}/src/java.base/share/native/include \
51104 51104 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS/native/include \
51105 51105 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS_TYPE/native/include \
51106 51106 -I${JDK_TOPDIR}/src/java.base/share/native/libjava \
51107 51107 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS_TYPE/native/libjava"
51108 51108
51109 51109 # The shared libraries are compiled using the picflag.
51110 51110 OPENJDK_BUILD_CFLAGS_JDKLIB="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
51111 51111 $OPENJDK_BUILD_CFLAGS_JDK $OPENJDK_BUILD_EXTRA_CFLAGS_JDK $PICFLAG $OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA"
51112 51112 OPENJDK_BUILD_CXXFLAGS_JDKLIB="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
51113 51113 $OPENJDK_BUILD_CXXFLAGS_JDK $OPENJDK_BUILD_EXTRA_CXXFLAGS_JDK $PICFLAG $OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA"
51114 51114
51115 51115 # Executable flags
51116 51116 OPENJDK_BUILD_CFLAGS_JDKEXE="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $OPENJDK_BUILD_CFLAGS_JDK $OPENJDK_BUILD_EXTRA_CFLAGS_JDK"
51117 51117 OPENJDK_BUILD_CXXFLAGS_JDKEXE="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $OPENJDK_BUILD_CXXFLAGS_JDK $OPENJDK_BUILD_EXTRA_CXXFLAGS_JDK"
51118 51118
51119 51119
51120 51120
51121 51121
51122 51122
51123 51123
51124 51124 # Setup LDFLAGS et al.
51125 51125 #
51126 51126
51127 51127 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
51128 51128 LDFLAGS_MICROSOFT="-nologo -opt:ref"
51129 51129 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
51130 51130 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
51131 51131 if test "x$OPENJDK_BUILD_CPU_BITS" = "x32"; then
51132 51132 LDFLAGS_SAFESH="-safeseh"
51133 51133 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_SAFESH"
51134 51134 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_SAFESH"
51135 51135 # NOTE: Old build added -machine. Probably not needed.
51136 51136 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -machine:I386"
51137 51137 else
51138 51138 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -machine:AMD64"
51139 51139 fi
51140 51140 elif test "x$TOOLCHAIN_TYPE" = xclang; then
51141 51141 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
51142 51142 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
51143 51143 # FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
51144 51144 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
51145 51145 fi
51146 51146 elif test "x$TOOLCHAIN_TYPE" = xgcc; then
51147 51147 # If this is a --hash-style=gnu system, use --hash-style=both, why?
51148 51148 # We have previously set HAS_GNU_HASH if this is the case
51149 51149 if test -n "$HAS_GNU_HASH"; then
51150 51150 OPENJDK_BUILD_LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
51151 51151 OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $OPENJDK_BUILD_LDFLAGS_HASH_STYLE"
51152 51152 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $OPENJDK_BUILD_LDFLAGS_HASH_STYLE"
51153 51153 fi
51154 51154 if test "x$OPENJDK_BUILD_OS" = xmacosx; then
51155 51155 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
51156 51156 fi
51157 51157 if test "x$OPENJDK_BUILD_OS" = xlinux; then
51158 51158 # And since we now know that the linker is gnu, then add -z defs, to forbid
51159 51159 # undefined symbols in object files.
51160 51160 LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
51161 51161 OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
51162 51162 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_NO_UNDEF_SYM"
51163 51163 LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
51164 51164 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
51165 51165 if test "x$OPENJDK_BUILD_CPU" = xx86; then
51166 51166 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -march=i586"
51167 51167 fi
51168 51168 case $DEBUG_LEVEL in
51169 51169 release )
51170 51170 # tell linker to optimize libraries.
51171 51171 # Should this be supplied to the OSS linker as well?
51172 51172 LDFLAGS_DEBUGLEVEL_release="-Wl,-O1"
51173 51173 OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_DEBUGLEVEL_release"
51174 51174 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_DEBUGLEVEL_release"
51175 51175 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
51176 51176 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
51177 51177 fi
51178 51178 ;;
51179 51179 slowdebug )
51180 51180 # Hotspot always let the linker optimize
51181 51181 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-O1"
51182 51182 if test "x$HAS_LINKER_NOW" = "xtrue"; then
51183 51183 # do relocations at load
51184 51184 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_NOW_FLAG"
51185 51185 OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
51186 51186 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_NOW_FLAG"
51187 51187 fi
51188 51188 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
51189 51189 # mark relocations read only
51190 51190 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_RELRO_FLAG"
51191 51191 OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
51192 51192 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
51193 51193 fi
51194 51194 ;;
51195 51195 fastdebug )
51196 51196 # Hotspot always let the linker optimize
51197 51197 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-O1"
51198 51198 if test "x$HAS_LINKER_RELRO" = "xtrue"; then
51199 51199 # mark relocations read only
51200 51200 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_RELRO_FLAG"
51201 51201 OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
51202 51202 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
51203 51203 fi
51204 51204 ;;
51205 51205 * )
51206 51206 as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
51207 51207 ;;
51208 51208 esac
51209 51209 fi
51210 51210 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
51211 51211 LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
51212 51212 OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
51213 51213 LDFLAGS_CXX_SOLSTUDIO="-norunpath"
51214 51214 OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
51215 51215 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
51216 51216 if test "x$OPENJDK_BUILD_CPU_ARCH" = "xsparc"; then
51217 51217 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -xarch=sparc"
51218 51218 fi
51219 51219 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
51220 51220 LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok"
51221 51221 OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_XLC"
51222 51222 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_XLC"
51223 51223 fi
51224 51224
51225 51225 # Customize LDFLAGS for executables
51226 51226
51227 51227 OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDK}"
51228 51228
51229 51229 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
51230 51230 if test "x$OPENJDK_BUILD_CPU_BITS" = "x64"; then
51231 51231 LDFLAGS_STACK_SIZE=1048576
51232 51232 else
51233 51233 LDFLAGS_STACK_SIZE=327680
51234 51234 fi
51235 51235 OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
51236 51236 elif test "x$OPENJDK_BUILD_OS" = xlinux; then
51237 51237 OPENJDK_BUILD_LDFLAGS_JDKEXE="$OPENJDK_BUILD_LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
51238 51238 fi
51239 51239
51240 51240 OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDKEXE} ${OPENJDK_BUILD_EXTRA_LDFLAGS_JDK}"
51241 51241
51242 51242 # Customize LDFLAGS for libs
51243 51243 OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDK}"
51244 51244
51245 51245 OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS}"
51246 51246 if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
51247 51247 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
51248 51248 -libpath:${OUTPUT_ROOT}/support/modules_libs/java.base"
51249 51249 OPENJDK_BUILD_JDKLIB_LIBS=""
51250 51250 else
51251 51251 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
51252 51252 -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)"
51253 51253
51254 51254 if test "xBUILD" = "xTARGET"; then
51255 51255 # On some platforms (mac) the linker warns about non existing -L dirs.
51256 51256 # Add server first if available. Linking aginst client does not always produce the same results.
51257 51257 # Only add client/minimal dir if client/minimal is being built.
51258 51258 # Default to server for other variants.
51259 51259 if [[ " $JVM_VARIANTS " =~ " server " ]] ; then
51260 51260 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)/server"
51261 51261 elif [[ " $JVM_VARIANTS " =~ " client " ]] ; then
51262 51262 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)/client"
51263 51263 elif [[ " $JVM_VARIANTS " =~ " minimal " ]] ; then
51264 51264 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)/minimal"
51265 51265 else
51266 51266 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)/server"
51267 51267 fi
51268 51268 elif test "xBUILD" = "xBUILD"; then
51269 51269 # When building a buildjdk, it's always only the server variant
51270 51270 OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
51271 51271 -L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base\$(OPENJDK_BUILD_CPU_LIBDIR)/server"
51272 51272 fi
51273 51273
51274 51274 OPENJDK_BUILD_JDKLIB_LIBS="-ljava -ljvm"
51275 51275 if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
51276 51276 OPENJDK_BUILD_JDKLIB_LIBS="$OPENJDK_BUILD_JDKLIB_LIBS -lc"
51277 51277 fi
51278 51278
51279 51279 fi
51280 51280
51281 51281 OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${OPENJDK_BUILD_JAVA_BASE_LDFLAGS}"
51282 51282
51283 51283 # Set OPENJDK_BUILD_JVM_LIBS (per os)
51284 51284 if test "x$OPENJDK_BUILD_OS" = xlinux; then
51285 51285 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm -ldl -lpthread"
51286 51286 elif test "x$OPENJDK_BUILD_OS" = xsolaris; then
51287 51287 # FIXME: This hard-coded path is not really proper.
51288 51288 if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
51289 51289 OPENJDK_BUILD_SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
51290 51290 elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
51291 51291 OPENJDK_BUILD_SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
51292 51292 fi
51293 51293 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
51294 51294 -lthread -ldoor -lc -ldemangle -lnsl -lkstat -lrt"
51295 51295 elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
51296 51296 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm"
51297 51297 elif test "x$OPENJDK_BUILD_OS" = xaix; then
51298 51298 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
51299 51299 elif test "x$OPENJDK_BUILD_OS" = xbsd; then
51300 51300 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm"
51301 51301 elif test "x$OPENJDK_BUILD_OS" = xwindows; then
51302 51302 OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
51303 51303 comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
51304 51304 wsock32.lib winmm.lib version.lib psapi.lib"
51305 51305 fi
51306 51306
51307 51307 # Set OPENJDK_BUILD_JVM_ASFLAGS
51308 51308 if test "x$OPENJDK_BUILD_OS" = xlinux; then
51309 51309 if test "x$OPENJDK_BUILD_CPU" = xx86; then
51310 51310 OPENJDK_BUILD_JVM_ASFLAGS="$OPENJDK_BUILD_JVM_ASFLAGS -march=i586"
51311 51311 fi
51312 51312 elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
51313 51313 OPENJDK_BUILD_JVM_ASFLAGS="$OPENJDK_BUILD_JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
51314 51314 fi
51315 51315
51316 51316 OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${OPENJDK_BUILD_EXTRA_LDFLAGS_JDK}"
51317 51317
51318 51318
51319 51319
51320 51320
51321 51321
51322 51322
51323 51323
51324 51324
51325 51325
51326 51326
51327 51327
51328 51328
51329 51329
51330 51330
51331 51331
51332 51332 # Tests are only ever compiled for TARGET
51333 51333 # Flags for compiling test libraries
51334 51334 CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
51335 51335 CXXFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"
51336 51336
51337 51337 # Flags for compiling test executables
51338 51338 CFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
51339 51339 CXXFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
51340 51340
51341 51341
51342 51342
51343 51343
51344 51344
51345 51345
51346 51346 LDFLAGS_TESTLIB="$LDFLAGS_JDKLIB"
51347 51347 LDFLAGS_TESTEXE="$LDFLAGS_JDKEXE $JAVA_BASE_LDFLAGS"
51348 51348
51349 51349
51350 51350
51351 51351
51352 51352
51353 51353
51354 51354 # Some Zero and Shark settings.
51355 51355 # ZERO_ARCHFLAG tells the compiler which mode to build for
51356 51356 case "${OPENJDK_TARGET_CPU}" in
51357 51357 s390)
51358 51358 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31"
51359 51359 ;;
51360 51360 *)
51361 51361 ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
51362 51362 esac
51363 51363
51364 51364
51365 51365
51366 51366
51367 51367
51368 51368
51369 51369
51370 51370
51371 51371
51372 51372
51373 51373
51374 51374
51375 51375
51376 51376
51377 51377
51378 51378
51379 51379
51380 51380
51381 51381
51382 51382
51383 51383
51384 51384
51385 51385
51386 51386
51387 51387
51388 51388
51389 51389
51390 51390
51391 51391
51392 51392
51393 51393
51394 51394
51395 51395
51396 51396
51397 51397
51398 51398
51399 51399
51400 51400
51401 51401
51402 51402
51403 51403
51404 51404
51405 51405 # Execute function body
51406 51406
51407 51407
51408 51408
51409 51409
51410 51410
51411 51411
51412 51412
51413 51413
51414 51414
51415 51415
51416 51416
51417 51417
51418 51418
51419 51419
51420 51420
51421 51421
51422 51422
51423 51423
51424 51424
51425 51425
51426 51426
51427 51427
51428 51428
51429 51429
51430 51430
51431 51431
51432 51432
51433 51433
51434 51434
51435 51435
51436 51436
51437 51437
51438 51438
51439 51439
51440 51440
51441 51441
51442 51442
51443 51443
51444 51444
51445 51445
51446 51446
51447 51447
51448 51448
51449 51449
51450 51450
51451 51451
51452 51452
51453 51453
51454 51454 # Execute function body
51455 51455
51456 51456 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
51457 51457 $as_echo_n "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
51458 51458 supports=yes
51459 51459
51460 51460 saved_cflags="$CFLAGS"
51461 51461 CFLAGS="$CFLAGS $ZERO_ARCHFLAG"
51462 51462 ac_ext=c
51463 51463 ac_cpp='$CPP $CPPFLAGS'
51464 51464 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51465 51465 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51466 51466 ac_compiler_gnu=$ac_cv_c_compiler_gnu
51467 51467
51468 51468 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
51469 51469 /* end confdefs.h. */
51470 51470 int i;
51471 51471 _ACEOF
51472 51472 if ac_fn_c_try_compile "$LINENO"; then :
51473 51473
51474 51474 else
51475 51475 supports=no
51476 51476 fi
51477 51477 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
51478 51478 ac_ext=cpp
51479 51479 ac_cpp='$CXXCPP $CPPFLAGS'
51480 51480 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51481 51481 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51482 51482 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51483 51483
51484 51484 CFLAGS="$saved_cflags"
51485 51485
51486 51486 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51487 51487 $as_echo "$supports" >&6; }
51488 51488 if test "x$supports" = "xyes" ; then
51489 51489 :
51490 51490 C_COMP_SUPPORTS="yes"
51491 51491 else
51492 51492 :
51493 51493 C_COMP_SUPPORTS="no"
51494 51494 fi
51495 51495
51496 51496
51497 51497
51498 51498
51499 51499
51500 51500
51501 51501
51502 51502
51503 51503
51504 51504
51505 51505
51506 51506
51507 51507
51508 51508
51509 51509
51510 51510
51511 51511
51512 51512
51513 51513
51514 51514
51515 51515
51516 51516
51517 51517
51518 51518
51519 51519
51520 51520
51521 51521
51522 51522
51523 51523
51524 51524
51525 51525
51526 51526
51527 51527
51528 51528
51529 51529
51530 51530
51531 51531
51532 51532
51533 51533
51534 51534
51535 51535
51536 51536
51537 51537
51538 51538
51539 51539
51540 51540
51541 51541
51542 51542
51543 51543
51544 51544
51545 51545
51546 51546
51547 51547
51548 51548
51549 51549
51550 51550
51551 51551
51552 51552
51553 51553
51554 51554 # Execute function body
51555 51555
51556 51556 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
51557 51557 $as_echo_n "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
51558 51558 supports=yes
51559 51559
51560 51560 saved_cxxflags="$CXXFLAGS"
51561 51561 CXXFLAGS="$CXXFLAG $ZERO_ARCHFLAG"
51562 51562 ac_ext=cpp
51563 51563 ac_cpp='$CXXCPP $CPPFLAGS'
51564 51564 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51565 51565 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51566 51566 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51567 51567
51568 51568 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
51569 51569 /* end confdefs.h. */
51570 51570 int i;
51571 51571 _ACEOF
51572 51572 if ac_fn_cxx_try_compile "$LINENO"; then :
51573 51573
51574 51574 else
51575 51575 supports=no
51576 51576 fi
51577 51577 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
51578 51578 ac_ext=cpp
51579 51579 ac_cpp='$CXXCPP $CPPFLAGS'
51580 51580 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51581 51581 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51582 51582 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51583 51583
51584 51584 CXXFLAGS="$saved_cxxflags"
51585 51585
51586 51586 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51587 51587 $as_echo "$supports" >&6; }
51588 51588 if test "x$supports" = "xyes" ; then
51589 51589 :
51590 51590 CXX_COMP_SUPPORTS="yes"
51591 51591 else
51592 51592 :
51593 51593 CXX_COMP_SUPPORTS="no"
51594 51594 fi
51595 51595
51596 51596
51597 51597
51598 51598
51599 51599
51600 51600
51601 51601
51602 51602
51603 51603
51604 51604
51605 51605
51606 51606
51607 51607
51608 51608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
51609 51609 $as_echo_n "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
51610 51610 supports=no
51611 51611 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
51612 51612
51613 51613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51614 51614 $as_echo "$supports" >&6; }
51615 51615 if test "x$supports" = "xyes" ; then
51616 51616 :
51617 51617
51618 51618 else
51619 51619 :
51620 51620 ZERO_ARCHFLAG=""
51621 51621 fi
51622 51622
51623 51623
51624 51624
51625 51625
51626 51626
51627 51627
51628 51628
51629 51629
51630 51630 # Check that the compiler supports -mX (or -qX on AIX) flags
51631 51631 # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
51632 51632
51633 51633
51634 51634
51635 51635
51636 51636
51637 51637
51638 51638
51639 51639
51640 51640
51641 51641
51642 51642
51643 51643
51644 51644
51645 51645
51646 51646
51647 51647
51648 51648
51649 51649
51650 51650
51651 51651
51652 51652
51653 51653
51654 51654
51655 51655
51656 51656
51657 51657
51658 51658
51659 51659
51660 51660
51661 51661
51662 51662
51663 51663
51664 51664
51665 51665
51666 51666
51667 51667
51668 51668
51669 51669
51670 51670
51671 51671
51672 51672
51673 51673
51674 51674
51675 51675
51676 51676
51677 51677
51678 51678
51679 51679 # Execute function body
51680 51680
51681 51681
51682 51682
51683 51683
51684 51684
51685 51685
51686 51686
51687 51687
51688 51688
51689 51689
51690 51690
51691 51691
51692 51692
51693 51693
51694 51694
51695 51695
51696 51696
51697 51697
51698 51698
51699 51699
51700 51700
51701 51701
51702 51702
51703 51703
51704 51704
51705 51705
51706 51706
51707 51707
51708 51708
51709 51709
51710 51710
51711 51711
51712 51712
51713 51713
51714 51714
51715 51715
51716 51716
51717 51717
51718 51718
51719 51719
51720 51720
51721 51721
51722 51722
51723 51723
51724 51724
51725 51725
51726 51726
51727 51727
51728 51728 # Execute function body
51729 51729
51730 51730 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
51731 51731 $as_echo_n "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
51732 51732 supports=yes
51733 51733
51734 51734 saved_cflags="$CFLAGS"
51735 51735 CFLAGS="$CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
51736 51736 ac_ext=c
51737 51737 ac_cpp='$CPP $CPPFLAGS'
51738 51738 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51739 51739 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51740 51740 ac_compiler_gnu=$ac_cv_c_compiler_gnu
51741 51741
51742 51742 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
51743 51743 /* end confdefs.h. */
51744 51744 int i;
51745 51745 _ACEOF
51746 51746 if ac_fn_c_try_compile "$LINENO"; then :
51747 51747
51748 51748 else
51749 51749 supports=no
51750 51750 fi
51751 51751 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
51752 51752 ac_ext=cpp
51753 51753 ac_cpp='$CXXCPP $CPPFLAGS'
51754 51754 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51755 51755 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51756 51756 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51757 51757
51758 51758 CFLAGS="$saved_cflags"
51759 51759
51760 51760 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51761 51761 $as_echo "$supports" >&6; }
51762 51762 if test "x$supports" = "xyes" ; then
51763 51763 :
51764 51764 C_COMP_SUPPORTS="yes"
51765 51765 else
51766 51766 :
51767 51767 C_COMP_SUPPORTS="no"
51768 51768 fi
51769 51769
51770 51770
51771 51771
51772 51772
51773 51773
51774 51774
51775 51775
51776 51776
51777 51777
51778 51778
51779 51779
51780 51780
51781 51781
51782 51782
51783 51783
51784 51784
51785 51785
51786 51786
51787 51787
51788 51788
51789 51789
51790 51790
51791 51791
51792 51792
51793 51793
51794 51794
51795 51795
51796 51796
51797 51797
51798 51798
51799 51799
51800 51800
51801 51801
51802 51802
51803 51803
51804 51804
51805 51805
51806 51806
51807 51807
51808 51808
51809 51809
51810 51810
51811 51811
51812 51812
51813 51813
51814 51814
51815 51815
51816 51816
51817 51817
51818 51818
51819 51819
51820 51820
51821 51821
51822 51822
51823 51823
51824 51824
51825 51825
51826 51826
51827 51827
51828 51828 # Execute function body
51829 51829
51830 51830 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
51831 51831 $as_echo_n "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
51832 51832 supports=yes
51833 51833
51834 51834 saved_cxxflags="$CXXFLAGS"
51835 51835 CXXFLAGS="$CXXFLAG ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
51836 51836 ac_ext=cpp
51837 51837 ac_cpp='$CXXCPP $CPPFLAGS'
51838 51838 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51839 51839 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51840 51840 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51841 51841
51842 51842 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
51843 51843 /* end confdefs.h. */
51844 51844 int i;
51845 51845 _ACEOF
51846 51846 if ac_fn_cxx_try_compile "$LINENO"; then :
51847 51847
51848 51848 else
51849 51849 supports=no
51850 51850 fi
51851 51851 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
51852 51852 ac_ext=cpp
51853 51853 ac_cpp='$CXXCPP $CPPFLAGS'
51854 51854 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
51855 51855 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
51856 51856 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
51857 51857
51858 51858 CXXFLAGS="$saved_cxxflags"
51859 51859
51860 51860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51861 51861 $as_echo "$supports" >&6; }
51862 51862 if test "x$supports" = "xyes" ; then
51863 51863 :
51864 51864 CXX_COMP_SUPPORTS="yes"
51865 51865 else
51866 51866 :
51867 51867 CXX_COMP_SUPPORTS="no"
51868 51868 fi
51869 51869
51870 51870
51871 51871
51872 51872
51873 51873
51874 51874
51875 51875
51876 51876
51877 51877
51878 51878
51879 51879
51880 51880
51881 51881
51882 51882 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
51883 51883 $as_echo_n "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
51884 51884 supports=no
51885 51885 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
51886 51886
51887 51887 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
51888 51888 $as_echo "$supports" >&6; }
51889 51889 if test "x$supports" = "xyes" ; then
51890 51890 :
51891 51891 COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
51892 51892 else
51893 51893 :
51894 51894 COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
51895 51895 fi
51896 51896
51897 51897
51898 51898
51899 51899
51900 51900
51901 51901
51902 51902
51903 51903
51904 51904 # Check whether --enable-warnings-as-errors was given.
51905 51905 if test "${enable_warnings_as_errors+set}" = set; then :
51906 51906 enableval=$enable_warnings_as_errors;
51907 51907 fi
51908 51908
51909 51909
51910 51910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if native warnings are errors" >&5
51911 51911 $as_echo_n "checking if native warnings are errors... " >&6; }
51912 51912 if test "x$enable_warnings_as_errors" = "xyes"; then
51913 51913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (explicitely set)" >&5
51914 51914 $as_echo "yes (explicitely set)" >&6; }
51915 51915 WARNINGS_AS_ERRORS=true
51916 51916 elif test "x$enable_warnings_as_errors" = "xno"; then
51917 51917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
51918 51918 $as_echo "no" >&6; }
51919 51919 WARNINGS_AS_ERRORS=false
51920 51920 elif test "x$enable_warnings_as_errors" = "x"; then
51921 51921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
51922 51922 $as_echo "yes (default)" >&6; }
51923 51923 WARNINGS_AS_ERRORS=true
51924 51924 else
51925 51925 as_fn_error $? "--enable-warnings-as-errors accepts no argument" "$LINENO" 5
51926 51926 fi
51927 51927
51928 51928 if test "x$WARNINGS_AS_ERRORS" = "xfalse"; then
51929 51929 # Set legacy hotspot variable
51930 51930 HOTSPOT_SET_WARNINGS_AS_ERRORS="WARNINGS_ARE_ERRORS="
51931 51931 else
51932 51932 HOTSPOT_SET_WARNINGS_AS_ERRORS=""
51933 51933 fi
51934 51934
51935 51935
51936 51936
51937 51937
51938 51938 case "${TOOLCHAIN_TYPE}" in
51939 51939 microsoft)
51940 51940 DISABLE_WARNING_PREFIX="-wd"
51941 51941 CFLAGS_WARNINGS_ARE_ERRORS="-WX"
51942 51942 ;;
51943 51943 solstudio)
51944 51944 DISABLE_WARNING_PREFIX="-erroff="
51945 51945 CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"
51946 51946 ;;
51947 51947 gcc)
51948 51948 # Prior to gcc 4.4, a -Wno-X where X is unknown for that version of gcc will cause an error
51949 51949
51950 51950
51951 51951
51952 51952
51953 51953
51954 51954
51955 51955
51956 51956
51957 51957
51958 51958
51959 51959
51960 51960
51961 51961
51962 51962
51963 51963
51964 51964
51965 51965
51966 51966
51967 51967
51968 51968
51969 51969
51970 51970
51971 51971
51972 51972
51973 51973
51974 51974
51975 51975
51976 51976
51977 51977
51978 51978
51979 51979
51980 51980
51981 51981
51982 51982
51983 51983
51984 51984
51985 51985
51986 51986
51987 51987
51988 51988
51989 51989
51990 51990
51991 51991
51992 51992
51993 51993
51994 51994
51995 51995
51996 51996 # Execute function body
51997 51997
51998 51998
51999 51999
52000 52000
52001 52001
52002 52002
52003 52003
52004 52004
52005 52005
52006 52006
52007 52007
52008 52008
52009 52009
52010 52010
52011 52011
52012 52012
52013 52013
52014 52014
52015 52015
52016 52016
52017 52017
52018 52018
52019 52019
52020 52020
52021 52021
52022 52022
52023 52023
52024 52024
52025 52025
52026 52026
52027 52027
52028 52028
52029 52029
52030 52030
52031 52031
52032 52032
52033 52033
52034 52034
52035 52035
52036 52036
52037 52037
52038 52038
52039 52039
52040 52040
52041 52041
52042 52042
52043 52043
52044 52044
52045 52045 # Execute function body
52046 52046
52047 52047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52048 52048 $as_echo_n "checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52049 52049 supports=yes
52050 52050
52051 52051 saved_cflags="$CFLAGS"
52052 52052 CFLAGS="$CFLAGS -Wno-this-is-a-warning-that-do-not-exist"
52053 52053 ac_ext=c
52054 52054 ac_cpp='$CPP $CPPFLAGS'
52055 52055 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52056 52056 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52057 52057 ac_compiler_gnu=$ac_cv_c_compiler_gnu
52058 52058
52059 52059 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
52060 52060 /* end confdefs.h. */
52061 52061 int i;
52062 52062 _ACEOF
52063 52063 if ac_fn_c_try_compile "$LINENO"; then :
52064 52064
52065 52065 else
52066 52066 supports=no
52067 52067 fi
52068 52068 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
52069 52069 ac_ext=cpp
52070 52070 ac_cpp='$CXXCPP $CPPFLAGS'
52071 52071 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52072 52072 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52073 52073 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52074 52074
52075 52075 CFLAGS="$saved_cflags"
52076 52076
52077 52077 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52078 52078 $as_echo "$supports" >&6; }
52079 52079 if test "x$supports" = "xyes" ; then
52080 52080 :
52081 52081 C_COMP_SUPPORTS="yes"
52082 52082 else
52083 52083 :
52084 52084 C_COMP_SUPPORTS="no"
52085 52085 fi
52086 52086
52087 52087
52088 52088
52089 52089
52090 52090
52091 52091
52092 52092
52093 52093
52094 52094
52095 52095
52096 52096
52097 52097
52098 52098
52099 52099
52100 52100
52101 52101
52102 52102
52103 52103
52104 52104
52105 52105
52106 52106
52107 52107
52108 52108
52109 52109
52110 52110
52111 52111
52112 52112
52113 52113
52114 52114
52115 52115
52116 52116
52117 52117
52118 52118
52119 52119
52120 52120
52121 52121
52122 52122
52123 52123
52124 52124
52125 52125
52126 52126
52127 52127
52128 52128
52129 52129
52130 52130
52131 52131
52132 52132
52133 52133
52134 52134
52135 52135
52136 52136
52137 52137
52138 52138
52139 52139
52140 52140
52141 52141
52142 52142
52143 52143
52144 52144
52145 52145 # Execute function body
52146 52146
52147 52147 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52148 52148 $as_echo_n "checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52149 52149 supports=yes
52150 52150
52151 52151 saved_cxxflags="$CXXFLAGS"
52152 52152 CXXFLAGS="$CXXFLAG -Wno-this-is-a-warning-that-do-not-exist"
52153 52153 ac_ext=cpp
52154 52154 ac_cpp='$CXXCPP $CPPFLAGS'
52155 52155 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52156 52156 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52157 52157 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52158 52158
52159 52159 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
52160 52160 /* end confdefs.h. */
52161 52161 int i;
52162 52162 _ACEOF
52163 52163 if ac_fn_cxx_try_compile "$LINENO"; then :
52164 52164
52165 52165 else
52166 52166 supports=no
52167 52167 fi
52168 52168 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
52169 52169 ac_ext=cpp
52170 52170 ac_cpp='$CXXCPP $CPPFLAGS'
52171 52171 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52172 52172 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52173 52173 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52174 52174
52175 52175 CXXFLAGS="$saved_cxxflags"
52176 52176
52177 52177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52178 52178 $as_echo "$supports" >&6; }
52179 52179 if test "x$supports" = "xyes" ; then
52180 52180 :
52181 52181 CXX_COMP_SUPPORTS="yes"
52182 52182 else
52183 52183 :
52184 52184 CXX_COMP_SUPPORTS="no"
52185 52185 fi
52186 52186
52187 52187
52188 52188
52189 52189
52190 52190
52191 52191
52192 52192
52193 52193
52194 52194
52195 52195
52196 52196
52197 52197
52198 52198
52199 52199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52200 52200 $as_echo_n "checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52201 52201 supports=no
52202 52202 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
52203 52203
52204 52204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52205 52205 $as_echo "$supports" >&6; }
52206 52206 if test "x$supports" = "xyes" ; then
52207 52207 :
52208 52208 GCC_CAN_DISABLE_WARNINGS=true
52209 52209 else
52210 52210 :
52211 52211 GCC_CAN_DISABLE_WARNINGS=false
52212 52212
52213 52213 fi
52214 52214
52215 52215
52216 52216
52217 52217
52218 52218
52219 52219
52220 52220 if test "x$GCC_CAN_DISABLE_WARNINGS" = "xtrue"; then
52221 52221 DISABLE_WARNING_PREFIX="-Wno-"
52222 52222 else
52223 52223 DISABLE_WARNING_PREFIX=
52224 52224 fi
52225 52225 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
52226 52226 # Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset
52227 52227 # CFLAGS since any target specific flags will likely not work with the
52228 52228 # build compiler
52229 52229 CC_OLD="$CC"
52230 52230 CXX_OLD="$CXX"
52231 52231 CC="$BUILD_CC"
52232 52232 CXX="$BUILD_CXX"
52233 52233 CFLAGS_OLD="$CFLAGS"
52234 52234 CFLAGS=""
52235 52235
52236 52236
52237 52237
52238 52238
52239 52239
52240 52240
52241 52241
52242 52242
52243 52243
52244 52244
52245 52245
52246 52246
52247 52247
52248 52248
52249 52249
52250 52250
52251 52251
52252 52252
52253 52253
52254 52254
52255 52255
52256 52256
52257 52257
52258 52258
52259 52259
52260 52260
52261 52261
52262 52262
52263 52263
52264 52264
52265 52265
52266 52266
52267 52267
52268 52268
52269 52269
52270 52270
52271 52271
52272 52272
52273 52273
52274 52274
52275 52275
52276 52276
52277 52277
52278 52278
52279 52279
52280 52280
52281 52281
52282 52282 # Execute function body
52283 52283
52284 52284
52285 52285
52286 52286
52287 52287
52288 52288
52289 52289
52290 52290
52291 52291
52292 52292
52293 52293
52294 52294
52295 52295
52296 52296
52297 52297
52298 52298
52299 52299
52300 52300
52301 52301
52302 52302
52303 52303
52304 52304
52305 52305
52306 52306
52307 52307
52308 52308
52309 52309
52310 52310
52311 52311
52312 52312
52313 52313
52314 52314
52315 52315
52316 52316
52317 52317
52318 52318
52319 52319
52320 52320
52321 52321
52322 52322
52323 52323
52324 52324
52325 52325
52326 52326
52327 52327
52328 52328
52329 52329
52330 52330
52331 52331 # Execute function body
52332 52332
52333 52333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52334 52334 $as_echo_n "checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52335 52335 supports=yes
52336 52336
52337 52337 saved_cflags="$CFLAGS"
52338 52338 CFLAGS="$CFLAGS -Wno-this-is-a-warning-that-do-not-exist"
52339 52339 ac_ext=c
52340 52340 ac_cpp='$CPP $CPPFLAGS'
52341 52341 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52342 52342 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52343 52343 ac_compiler_gnu=$ac_cv_c_compiler_gnu
52344 52344
52345 52345 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
52346 52346 /* end confdefs.h. */
52347 52347 int i;
52348 52348 _ACEOF
52349 52349 if ac_fn_c_try_compile "$LINENO"; then :
52350 52350
52351 52351 else
52352 52352 supports=no
52353 52353 fi
52354 52354 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
52355 52355 ac_ext=cpp
52356 52356 ac_cpp='$CXXCPP $CPPFLAGS'
52357 52357 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52358 52358 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52359 52359 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52360 52360
52361 52361 CFLAGS="$saved_cflags"
52362 52362
52363 52363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52364 52364 $as_echo "$supports" >&6; }
52365 52365 if test "x$supports" = "xyes" ; then
52366 52366 :
52367 52367 C_COMP_SUPPORTS="yes"
52368 52368 else
52369 52369 :
52370 52370 C_COMP_SUPPORTS="no"
52371 52371 fi
52372 52372
52373 52373
52374 52374
52375 52375
52376 52376
52377 52377
52378 52378
52379 52379
52380 52380
52381 52381
52382 52382
52383 52383
52384 52384
52385 52385
52386 52386
52387 52387
52388 52388
52389 52389
52390 52390
52391 52391
52392 52392
52393 52393
52394 52394
52395 52395
52396 52396
52397 52397
52398 52398
52399 52399
52400 52400
52401 52401
52402 52402
52403 52403
52404 52404
52405 52405
52406 52406
52407 52407
52408 52408
52409 52409
52410 52410
52411 52411
52412 52412
52413 52413
52414 52414
52415 52415
52416 52416
52417 52417
52418 52418
52419 52419
52420 52420
52421 52421
52422 52422
52423 52423
52424 52424
52425 52425
52426 52426
52427 52427
52428 52428
52429 52429
52430 52430
52431 52431 # Execute function body
52432 52432
52433 52433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52434 52434 $as_echo_n "checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52435 52435 supports=yes
52436 52436
52437 52437 saved_cxxflags="$CXXFLAGS"
52438 52438 CXXFLAGS="$CXXFLAG -Wno-this-is-a-warning-that-do-not-exist"
52439 52439 ac_ext=cpp
52440 52440 ac_cpp='$CXXCPP $CPPFLAGS'
52441 52441 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52442 52442 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52443 52443 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52444 52444
52445 52445 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
52446 52446 /* end confdefs.h. */
52447 52447 int i;
52448 52448 _ACEOF
52449 52449 if ac_fn_cxx_try_compile "$LINENO"; then :
52450 52450
52451 52451 else
52452 52452 supports=no
52453 52453 fi
52454 52454 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
52455 52455 ac_ext=cpp
52456 52456 ac_cpp='$CXXCPP $CPPFLAGS'
52457 52457 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
52458 52458 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
52459 52459 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
52460 52460
52461 52461 CXXFLAGS="$saved_cxxflags"
52462 52462
52463 52463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52464 52464 $as_echo "$supports" >&6; }
52465 52465 if test "x$supports" = "xyes" ; then
52466 52466 :
52467 52467 CXX_COMP_SUPPORTS="yes"
52468 52468 else
52469 52469 :
52470 52470 CXX_COMP_SUPPORTS="no"
52471 52471 fi
52472 52472
52473 52473
52474 52474
52475 52475
52476 52476
52477 52477
52478 52478
52479 52479
52480 52480
52481 52481
52482 52482
52483 52483
52484 52484
52485 52485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
52486 52486 $as_echo_n "checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
52487 52487 supports=no
52488 52488 if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
52489 52489
52490 52490 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
52491 52491 $as_echo "$supports" >&6; }
52492 52492 if test "x$supports" = "xyes" ; then
52493 52493 :
52494 52494 BUILD_CC_CAN_DISABLE_WARNINGS=true
52495 52495 else
52496 52496 :
52497 52497 BUILD_CC_CAN_DISABLE_WARNINGS=false
52498 52498
52499 52499 fi
52500 52500
52501 52501
52502 52502
52503 52503
52504 52504
52505 52505
52506 52506 if test "x$BUILD_CC_CAN_DISABLE_WARNINGS" = "xtrue"; then
52507 52507 BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-"
52508 52508 else
52509 52509 BUILD_CC_DISABLE_WARNING_PREFIX=
52510 52510 fi
52511 52511 CC="$CC_OLD"
52512 52512 CXX="$CXX_OLD"
52513 52513 CFLAGS="$CFLAGS_OLD"
52514 52514 ;;
52515 52515 clang)
52516 52516 DISABLE_WARNING_PREFIX="-Wno-"
52517 52517 CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
52518 52518 ;;
52519 52519 xlc)
52520 52520 DISABLE_WARNING_PREFIX="-qsuppress="
52521 52521 CFLAGS_WARNINGS_ARE_ERRORS="-qhalt=w"
52522 52522 ;;
52523 52523 esac
52524 52524
52525 52525
52526 52526
52527 52527
52528 52528
52529 52529 # Setup debug symbols (need objcopy from the toolchain for that)
52530 52530
52531 52531 #
52532 52532 # NATIVE_DEBUG_SYMBOLS
52533 52533 # This must be done after the toolchain is setup, since we're looking at objcopy.
52534 52534 #
52535 52535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use" >&5
52536 52536 $as_echo_n "checking what type of native debug symbols to use... " >&6; }
52537 52537
52538 52538 # Check whether --with-native-debug-symbols was given.
52539 52539 if test "${with_native_debug_symbols+set}" = set; then :
52540 52540 withval=$with_native_debug_symbols;
52541 52541 if test "x$OPENJDK_TARGET_OS" = xaix; then
52542 52542 if test "x$withval" = xexternal || test "x$withval" = xzipped; then
52543 52543 as_fn_error $? "AIX only supports the parameters 'none' and 'internal' for --with-native-debug-symbols" "$LINENO" 5
52544 52544 fi
52545 52545 fi
52546 52546
52547 52547 else
52548 52548
52549 52549 if test "x$OPENJDK_TARGET_OS" = xaix; then
52550 52550 # AIX doesn't support 'zipped' so use 'internal' as default
52551 52551 with_native_debug_symbols="internal"
52552 52552 else
52553 52553 if test "x$STATIC_BUILD" = xtrue; then
52554 52554 with_native_debug_symbols="none"
52555 52555 else
52556 52556 with_native_debug_symbols="zipped"
52557 52557 fi
52558 52558 fi
52559 52559
52560 52560 fi
52561 52561
52562 52562 NATIVE_DEBUG_SYMBOLS=$with_native_debug_symbols
52563 52563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
52564 52564 $as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
52565 52565
52566 52566 if test "x$NATIVE_DEBUG_SYMBOLS" = xzipped; then
52567 52567
52568 52568 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
52569 52569 if test "x$OBJCOPY" = x; then
52570 52570 # enabling of enable-debug-symbols and can't find objcopy
52571 52571 # this is an error
52572 52572 as_fn_error $? "Unable to find objcopy, cannot enable native debug symbols" "$LINENO" 5
52573 52573 fi
52574 52574 fi
52575 52575
52576 52576 COMPILE_WITH_DEBUG_SYMBOLS=true
52577 52577 COPY_DEBUG_SYMBOLS=true
52578 52578 ZIP_EXTERNAL_DEBUG_SYMBOLS=true
52579 52579
52580 52580 # Hotspot legacy support, not relevant with COPY_DEBUG_SYMBOLS=true
52581 52581 DEBUG_BINARIES=false
52582 52582 STRIP_POLICY=min_strip
52583 52583
52584 52584 elif test "x$NATIVE_DEBUG_SYMBOLS" = xnone; then
52585 52585 COMPILE_WITH_DEBUG_SYMBOLS=false
52586 52586 COPY_DEBUG_SYMBOLS=false
52587 52587 ZIP_EXTERNAL_DEBUG_SYMBOLS=false
52588 52588
52589 52589 DEBUG_BINARIES=false
52590 52590 STRIP_POLICY=no_strip
52591 52591 elif test "x$NATIVE_DEBUG_SYMBOLS" = xinternal; then
52592 52592 COMPILE_WITH_DEBUG_SYMBOLS=true
52593 52593 COPY_DEBUG_SYMBOLS=false
52594 52594 ZIP_EXTERNAL_DEBUG_SYMBOLS=false
52595 52595
52596 52596 # Hotspot legacy support, will turn on -g when COPY_DEBUG_SYMBOLS=false
52597 52597 DEBUG_BINARIES=true
52598 52598 STRIP_POLICY=no_strip
52599 52599 STRIP=""
52600 52600
52601 52601 elif test "x$NATIVE_DEBUG_SYMBOLS" = xexternal; then
52602 52602
52603 52603 if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
52604 52604 if test "x$OBJCOPY" = x; then
52605 52605 # enabling of enable-debug-symbols and can't find objcopy
52606 52606 # this is an error
52607 52607 as_fn_error $? "Unable to find objcopy, cannot enable native debug symbols" "$LINENO" 5
52608 52608 fi
52609 52609 fi
52610 52610
52611 52611 COMPILE_WITH_DEBUG_SYMBOLS=true
52612 52612 COPY_DEBUG_SYMBOLS=true
52613 52613 ZIP_EXTERNAL_DEBUG_SYMBOLS=false
52614 52614
52615 52615 # Hotspot legacy support, not relevant with COPY_DEBUG_SYMBOLS=true
52616 52616 DEBUG_BINARIES=false
52617 52617 STRIP_POLICY=min_strip
52618 52618 else
52619 52619 as_fn_error $? "Allowed native debug symbols are: none, internal, external, zipped" "$LINENO" 5
52620 52620 fi
52621 52621
52622 52622 # --enable-debug-symbols is deprecated.
52623 52623 # Please use --with-native-debug-symbols=[internal,external,zipped] .
52624 52624
52625 52625 # Check whether --enable-debug-symbols was given.
52626 52626 if test "${enable_debug_symbols+set}" = set; then :
52627 52627 enableval=$enable_debug_symbols;
52628 52628 fi
52629 52629
52630 52630 if test "x$enable_debug_symbols" != x; then
52631 52631 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-debug-symbols is deprecated and will be ignored." >&5
52632 52632 $as_echo "$as_me: WARNING: Option --enable-debug-symbols is deprecated and will be ignored." >&2;}
52633 52633
52634 52634 if test "xPlease use --with-native-debug-symbols=[internal,external,zipped] ." != x; then
52635 52635 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Please use --with-native-debug-symbols=[internal,external,zipped] ." >&5
52636 52636 $as_echo "$as_me: WARNING: Please use --with-native-debug-symbols=[internal,external,zipped] ." >&2;}
52637 52637 fi
52638 52638
52639 52639 fi
52640 52640
52641 52641
52642 52642 # --enable-zip-debug-info is deprecated.
52643 52643 # Please use --with-native-debug-symbols=zipped .
52644 52644
52645 52645 # Check whether --enable-zip-debug-info was given.
52646 52646 if test "${enable_zip_debug_info+set}" = set; then :
52647 52647 enableval=$enable_zip_debug_info;
52648 52648 fi
52649 52649
52650 52650 if test "x$enable_zip_debug_info" != x; then
52651 52651 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-zip-debug-info is deprecated and will be ignored." >&5
52652 52652 $as_echo "$as_me: WARNING: Option --enable-zip-debug-info is deprecated and will be ignored." >&2;}
52653 52653
52654 52654 if test "xPlease use --with-native-debug-symbols=zipped ." != x; then
52655 52655 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Please use --with-native-debug-symbols=zipped ." >&5
52656 52656 $as_echo "$as_me: WARNING: Please use --with-native-debug-symbols=zipped ." >&2;}
52657 52657 fi
52658 52658
52659 52659 fi
52660 52660
52661 52661
52662 52662
52663 52663
52664 52664
52665 52665
52666 52666 # Legacy values
52667 52667
52668 52668
52669 52669
52670 52670
52671 52671 # Check whether --enable-native-coverage was given.
52672 52672 if test "${enable_native_coverage+set}" = set; then :
52673 52673 enableval=$enable_native_coverage;
52674 52674 fi
52675 52675
52676 52676 GCOV_ENABLED="false"
52677 52677 if test "x$enable_native_coverage" = "xyes"; then
52678 52678 if test "x$TOOLCHAIN_TYPE" = "xgcc"; then
52679 52679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if native coverage is enabled" >&5
52680 52680 $as_echo_n "checking if native coverage is enabled... " >&6; }
52681 52681 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
52682 52682 $as_echo "yes" >&6; }
52683 52683 GCOV_CFLAGS="-fprofile-arcs -ftest-coverage -fno-inline"
52684 52684 GCOV_LDFLAGS="-fprofile-arcs"
52685 52685 LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $GCOV_CFLAGS"
52686 52686 LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $GCOV_CFLAGS"
52687 52687 LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $GCOV_LDFLAGS"
52688 52688 CFLAGS_JDKLIB="$CFLAGS_JDKLIB $GCOV_CFLAGS"
52689 52689 CFLAGS_JDKEXE="$CFLAGS_JDKEXE $GCOV_CFLAGS"
52690 52690 CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $GCOV_CFLAGS"
52691 52691 CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $GCOV_CFLAGS"
52692 52692 LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $GCOV_LDFLAGS"
52693 52693 LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $GCOV_LDFLAGS"
52694 52694 GCOV_ENABLED="true"
52695 52695 else
52696 52696 as_fn_error $? "--enable-native-coverage only works with toolchain type gcc" "$LINENO" 5
52697 52697 fi
52698 52698 elif test "x$enable_native_coverage" = "xno"; then
52699 52699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if native coverage is enabled" >&5
52700 52700 $as_echo_n "checking if native coverage is enabled... " >&6; }
52701 52701 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
52702 52702 $as_echo "no" >&6; }
52703 52703 elif test "x$enable_native_coverage" != "x"; then
52704 52704 as_fn_error $? "--enable-native-coverage can only be assigned \"yes\" or \"no\"" "$LINENO" 5
52705 52705 fi
52706 52706
52707 52707
52708 52708
52709 52709
52710 52710 # Need toolchain to setup dtrace
52711 52711
52712 52712 # Test for dtrace dependencies
52713 52713 # Check whether --enable-dtrace was given.
52714 52714 if test "${enable_dtrace+set}" = set; then :
52715 52715 enableval=$enable_dtrace;
52716 52716 fi
52717 52717
52718 52718
52719 52719 DTRACE_DEP_MISSING=false
52720 52720
52721 52721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dtrace tool" >&5
52722 52722 $as_echo_n "checking for dtrace tool... " >&6; }
52723 52723 if test "x$DTRACE" != "x" && test -x "$DTRACE"; then
52724 52724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
52725 52725 $as_echo "$DTRACE" >&6; }
52726 52726 else
52727 52727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found, cannot build dtrace" >&5
52728 52728 $as_echo "not found, cannot build dtrace" >&6; }
52729 52729 DTRACE_DEP_MISSING=true
52730 52730 fi
52731 52731
52732 52732 for ac_header in sys/sdt.h
52733 52733 do :
52734 52734 ac_fn_cxx_check_header_mongrel "$LINENO" "sys/sdt.h" "ac_cv_header_sys_sdt_h" "$ac_includes_default"
52735 52735 if test "x$ac_cv_header_sys_sdt_h" = xyes; then :
52736 52736 cat >>confdefs.h <<_ACEOF
52737 52737 #define HAVE_SYS_SDT_H 1
52738 52738 _ACEOF
52739 52739 DTRACE_HEADERS_OK=yes
52740 52740 else
52741 52741 DTRACE_HEADERS_OK=no
52742 52742 fi
52743 52743
52744 52744 done
52745 52745
52746 52746 if test "x$DTRACE_HEADERS_OK" != "xyes"; then
52747 52747 DTRACE_DEP_MISSING=true
52748 52748 fi
52749 52749
52750 52750 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dtrace should be built" >&5
52751 52751 $as_echo_n "checking if dtrace should be built... " >&6; }
52752 52752 if test "x$enable_dtrace" = "xyes"; then
52753 52753 if test "x$DTRACE_DEP_MISSING" = "xtrue"; then
52754 52754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
52755 52755 $as_echo "no, missing dependencies" >&6; }
52756 52756
52757 52757 # Print a helpful message on how to acquire the necessary build dependency.
52758 52758 # dtrace is the help tag: freetype, cups, alsa etc
52759 52759 MISSING_DEPENDENCY=dtrace
52760 52760
52761 52761 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
52762 52762 cygwin_help $MISSING_DEPENDENCY
52763 52763 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
52764 52764 msys_help $MISSING_DEPENDENCY
52765 52765 else
52766 52766 PKGHANDLER_COMMAND=
52767 52767
52768 52768 case $PKGHANDLER in
52769 52769 apt-get)
52770 52770 apt_help $MISSING_DEPENDENCY ;;
52771 52771 yum)
52772 52772 yum_help $MISSING_DEPENDENCY ;;
52773 52773 port)
52774 52774 port_help $MISSING_DEPENDENCY ;;
52775 52775 pkgutil)
52776 52776 pkgutil_help $MISSING_DEPENDENCY ;;
52777 52777 pkgadd)
52778 52778 pkgadd_help $MISSING_DEPENDENCY ;;
52779 52779 esac
52780 52780
52781 52781 if test "x$PKGHANDLER_COMMAND" != x; then
52782 52782 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
52783 52783 fi
52784 52784 fi
52785 52785
52786 52786 as_fn_error $? "Cannot enable dtrace with missing dependencies. See above. $HELP_MSG" "$LINENO" 5
52787 52787 else
52788 52788 INCLUDE_DTRACE=true
52789 52789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
52790 52790 $as_echo "yes, forced" >&6; }
52791 52791 fi
52792 52792 elif test "x$enable_dtrace" = "xno"; then
52793 52793 INCLUDE_DTRACE=false
52794 52794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
52795 52795 $as_echo "no, forced" >&6; }
52796 52796 elif test "x$enable_dtrace" = "xauto" || test "x$enable_dtrace" = "x"; then
52797 52797 if test "x$DTRACE_DEP_MISSING" = "xtrue"; then
52798 52798 INCLUDE_DTRACE=false
52799 52799 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
52800 52800 $as_echo "no, missing dependencies" >&6; }
52801 52801 else
52802 52802 INCLUDE_DTRACE=true
52803 52803 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, dependencies present" >&5
52804 52804 $as_echo "yes, dependencies present" >&6; }
52805 52805 fi
52806 52806 else
52807 52807 as_fn_error $? "Invalid value for --enable-dtrace: $enable_dtrace" "$LINENO" 5
52808 52808 fi
52809 52809
52810 52810
52811 52811
52812 52812 # The user can in some cases supply additional jvm features. For the custom
52813 52813 # variant, this defines the entire variant.
52814 52814
52815 52815 # Check whether --with-jvm-features was given.
52816 52816 if test "${with_jvm_features+set}" = set; then :
52817 52817 withval=$with_jvm_features;
52818 52818 fi
52819 52819
52820 52820 if test "x$with_jvm_features" != x; then
52821 52821 { $as_echo "$as_me:${as_lineno-$LINENO}: checking additional JVM features" >&5
52822 52822 $as_echo_n "checking additional JVM features... " >&6; }
52823 52823 JVM_FEATURES=`$ECHO $with_jvm_features | $SED -e 's/,/ /g'`
52824 52824 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_FEATURES" >&5
52825 52825 $as_echo "$JVM_FEATURES" >&6; }
52826 52826 fi
52827 52827
52828 52828 # Verify that dependencies are met for explicitly set features.
52829 52829 if [[ " $JVM_FEATURES " =~ " jvmti " ]] && ! [[ " $JVM_FEATURES " =~ " services " ]] ; then
52830 52830 as_fn_error $? "Specified JVM feature 'jvmti' requires feature 'services'" "$LINENO" 5
52831 52831 fi
52832 52832
52833 52833 if [[ " $JVM_FEATURES " =~ " management " ]] && ! [[ " $JVM_FEATURES " =~ " nmt " ]] ; then
52834 52834 as_fn_error $? "Specified JVM feature 'management' requires feature 'nmt'" "$LINENO" 5
52835 52835 fi
52836 52836
52837 52837 if [[ " $JVM_FEATURES " =~ " jvmci " ]] && ! ( [[ " $JVM_FEATURES " =~ " compiler1 " ]] || [[ " $JVM_FEATURES " =~ " compiler2 " ]] ); then
52838 52838 as_fn_error $? "Specified JVM feature 'jvmci' requires feature 'compiler2' or 'compiler1'" "$LINENO" 5
52839 52839 fi
52840 52840
52841 52841 if [[ " $JVM_FEATURES " =~ " compiler2 " ]] && ! [[ " $JVM_FEATURES " =~ " all-gcs " ]] ; then
52842 52842 as_fn_error $? "Specified JVM feature 'compiler2' requires feature 'all-gcs'" "$LINENO" 5
52843 52843 fi
52844 52844
52845 52845 if [[ " $JVM_FEATURES " =~ " vm-structs " ]] && ! [[ " $JVM_FEATURES " =~ " all-gcs " ]] ; then
52846 52846 as_fn_error $? "Specified JVM feature 'vm-structs' requires feature 'all-gcs'" "$LINENO" 5
52847 52847 fi
52848 52848
52849 52849 # Turn on additional features based on other parts of configure
52850 52850 if test "x$INCLUDE_DTRACE" = "xtrue"; then
52851 52851 JVM_FEATURES="$JVM_FEATURES dtrace"
52852 52852 else
52853 52853 if [[ " $JVM_FEATURES " =~ " dtrace " ]] ; then
52854 52854 as_fn_error $? "To enable dtrace, you must use --enable-dtrace" "$LINENO" 5
52855 52855 fi
52856 52856 fi
52857 52857
52858 52858 if test "x$STATIC_BUILD" = "xtrue"; then
52859 52859 JVM_FEATURES="$JVM_FEATURES static-build"
52860 52860 else
52861 52861 if [[ " $JVM_FEATURES " =~ " static-build " ]] ; then
52862 52862 as_fn_error $? "To enable static-build, you must use --enable-static-build" "$LINENO" 5
52863 52863 fi
52864 52864 fi
52865 52865
52866 52866 if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
52867 52867 if [[ " $JVM_FEATURES " =~ " zero " ]] ; then
52868 52868 as_fn_error $? "To enable zero/zeroshark, you must use --with-jvm-variants=zero/zeroshark" "$LINENO" 5
52869 52869 fi
52870 52870 fi
52871 52871
52872 52872 if ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
52873 52873 if [[ " $JVM_FEATURES " =~ " shark " ]] ; then
52874 52874 as_fn_error $? "To enable shark, you must use --with-jvm-variants=zeroshark" "$LINENO" 5
52875 52875 fi
52876 52876 fi
52877 52877
52878 52878 # Only enable jvmci on x86_64, sparcv9 and aarch64.
52879 52879 if test "x$OPENJDK_TARGET_CPU" = "xx86_64" || \
52880 52880 test "x$OPENJDK_TARGET_CPU" = "xsparcv9" || \
52881 52881 test "x$OPENJDK_TARGET_CPU" = "xaarch64" ; then
52882 52882 JVM_FEATURES_jvmci="jvmci"
52883 52883 else
52884 52884 JVM_FEATURES_jvmci=""
52885 52885 fi
52886 52886
52887 52887 # All variants but minimal (and custom) get these features
52888 52888 NON_MINIMAL_FEATURES="$NON_MINIMAL_FEATURES jvmti fprof vm-structs jni-check services management all-gcs nmt cds"
52889 52889
52890 52890 # Enable features depending on variant.
52891 52891 JVM_FEATURES_server="compiler1 compiler2 $NON_MINIMAL_FEATURES $JVM_FEATURES $JVM_FEATURES_jvmci"
52892 52892 JVM_FEATURES_client="compiler1 $NON_MINIMAL_FEATURES $JVM_FEATURES $JVM_FEATURES_jvmci"
52893 52893 JVM_FEATURES_core="$NON_MINIMAL_FEATURES $JVM_FEATURES"
52894 52894 JVM_FEATURES_minimal="compiler1 minimal $JVM_FEATURES"
52895 52895 JVM_FEATURES_zero="zero $NON_MINIMAL_FEATURES $JVM_FEATURES"
52896 52896 JVM_FEATURES_zeroshark="zero shark $NON_MINIMAL_FEATURES $JVM_FEATURES"
52897 52897 JVM_FEATURES_custom="$JVM_FEATURES"
52898 52898
52899 52899
52900 52900
52901 52901
52902 52902
52903 52903
52904 52904
52905 52905
52906 52906
52907 52907 # Used for verification of Makefiles by check-jvm-feature
52908 52908
52909 52909
52910 52910 # We don't support --with-jvm-interpreter anymore, use zero instead.
52911 52911
52912 52912
52913 52913 # Check whether --with-jvm-interpreter was given.
52914 52914 if test "${with_jvm_interpreter+set}" = set; then :
52915 52915 withval=$with_jvm_interpreter; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-jvm-interpreter is deprecated and will be ignored." >&5
52916 52916 $as_echo "$as_me: WARNING: Option --with-jvm-interpreter is deprecated and will be ignored." >&2;}
52917 52917 fi
52918 52918
52919 52919
52920 52920
52921 52921
52922 52922 # Check whether --enable-hotspot-gtest was given.
52923 52923 if test "${enable_hotspot_gtest+set}" = set; then :
52924 52924 enableval=$enable_hotspot_gtest;
52925 52925 fi
52926 52926
52927 52927
52928 52928 if test -e "$HOTSPOT_TOPDIR/test/native"; then
52929 52929 GTEST_DIR_EXISTS="true"
52930 52930 else
52931 52931 GTEST_DIR_EXISTS="false"
52932 52932 fi
52933 52933
52934 52934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Hotspot gtest unit tests should be built" >&5
52935 52935 $as_echo_n "checking if Hotspot gtest unit tests should be built... " >&6; }
52936 52936 if test "x$enable_hotspot_gtest" = "xyes"; then
52937 52937 if test "x$GTEST_DIR_EXISTS" = "xtrue"; then
52938 52938 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
52939 52939 $as_echo "yes, forced" >&6; }
52940 52940 BUILD_GTEST="true"
52941 52941 else
52942 52942 as_fn_error $? "Cannot build gtest without the test source" "$LINENO" 5
52943 52943 fi
52944 52944 elif test "x$enable_hotspot_gtest" = "xno"; then
52945 52945 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
52946 52946 $as_echo "no, forced" >&6; }
52947 52947 BUILD_GTEST="false"
52948 52948 elif test "x$enable_hotspot_gtest" = "x"; then
52949 52949 if test "x$GTEST_DIR_EXISTS" = "xtrue" && test "x$OPENJDK_TARGET_OS" != "xaix"; then
52950 52950 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
52951 52951 $as_echo "yes" >&6; }
52952 52952 BUILD_GTEST="true"
52953 52953 else
52954 52954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
52955 52955 $as_echo "no" >&6; }
52956 52956 BUILD_GTEST="false"
52957 52957 fi
52958 52958 else
52959 52959 as_fn_error $? "--enable-gtest must be either yes or no" "$LINENO" 5
52960 52960 fi
52961 52961
52962 52962
52963 52963
52964 52964
52965 52965 ###############################################################################
52966 52966 #
52967 52967 # Check dependencies for external and internal libraries.
52968 52968 #
52969 52969 ###############################################################################
52970 52970
52971 52971 # After we have toolchain, we can compile fixpath. It's needed by the lib checks.
52972 52972
52973 52973 # When using cygwin or msys, we need a wrapper binary that renames
52974 52974 # /cygdrive/c/ arguments into c:/ arguments and peeks into
52975 52975 # @files and rewrites these too! This wrapper binary is
52976 52976 # called fixpath.
52977 52977 FIXPATH=
52978 52978 if test "x$OPENJDK_BUILD_OS" = xwindows; then
52979 52979 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
52980 52980 $as_echo_n "checking if fixpath can be created... " >&6; }
52981 52981 FIXPATH_SRC="$SRC_ROOT/common/src/fixpath.c"
52982 52982 FIXPATH_BIN="$CONFIGURESUPPORT_OUTPUTDIR/bin/fixpath.exe"
52983 52983 FIXPATH_DIR="$CONFIGURESUPPORT_OUTPUTDIR/fixpath"
52984 52984 if test "x$OPENJDK_BUILD_OS_ENV" = xwindows.cygwin; then
52985 52985 # Important to keep the .exe suffix on Cygwin for Hotspot makefiles
52986 52986 FIXPATH="$FIXPATH_BIN -c"
52987 52987 elif test "x$OPENJDK_BUILD_OS_ENV" = xwindows.msys; then
52988 52988 # Take all collected prefixes and turn them into a -m/c/foo@/c/bar@... command line
52989 52989 # @ was chosen as separator to minimize risk of other tools messing around with it
52990 52990 all_unique_prefixes=`echo "${all_fixpath_prefixes[@]}" \
52991 52991 | tr ' ' '\n' | $GREP '^/./' | $SORT | $UNIQ`
52992 52992 fixpath_argument_list=`echo $all_unique_prefixes | tr ' ' '@'`
52993 52993 FIXPATH="$FIXPATH_BIN -m$fixpath_argument_list"
52994 52994 fi
52995 52995 FIXPATH_SRC_W="$FIXPATH_SRC"
52996 52996 FIXPATH_BIN_W="$FIXPATH_BIN"
52997 52997
52998 52998 unix_path="$FIXPATH_SRC_W"
52999 52999 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53000 53000 windows_path=`$CYGPATH -m "$unix_path"`
53001 53001 FIXPATH_SRC_W="$windows_path"
53002 53002 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53003 53003 windows_path=`cmd //c echo $unix_path`
53004 53004 FIXPATH_SRC_W="$windows_path"
53005 53005 fi
53006 53006
53007 53007
53008 53008 unix_path="$FIXPATH_BIN_W"
53009 53009 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53010 53010 windows_path=`$CYGPATH -m "$unix_path"`
53011 53011 FIXPATH_BIN_W="$windows_path"
53012 53012 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53013 53013 windows_path=`cmd //c echo $unix_path`
53014 53014 FIXPATH_BIN_W="$windows_path"
53015 53015 fi
53016 53016
53017 53017 $RM -rf $FIXPATH_BIN $FIXPATH_DIR
53018 53018 $MKDIR -p $FIXPATH_DIR $CONFIGURESUPPORT_OUTPUTDIR/bin
53019 53019 cd $FIXPATH_DIR
53020 53020 $CC $FIXPATH_SRC_W -Fe$FIXPATH_BIN_W > $FIXPATH_DIR/fixpath1.log 2>&1
53021 53021 cd $CURDIR
53022 53022
53023 53023 if test ! -x $FIXPATH_BIN; then
53024 53024 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
53025 53025 $as_echo "no" >&6; }
53026 53026 cat $FIXPATH_DIR/fixpath1.log
53027 53027 as_fn_error $? "Could not create $FIXPATH_BIN" "$LINENO" 5
53028 53028 fi
53029 53029 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
53030 53030 $as_echo "yes" >&6; }
53031 53031 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
53032 53032 $as_echo_n "checking if fixpath.exe works... " >&6; }
53033 53033 cd $FIXPATH_DIR
53034 53034 $FIXPATH $CC $FIXPATH_SRC -Fe$FIXPATH_DIR/fixpath2.exe \
53035 53035 > $FIXPATH_DIR/fixpath2.log 2>&1
53036 53036 cd $CURDIR
53037 53037 if test ! -x $FIXPATH_DIR/fixpath2.exe; then
53038 53038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
53039 53039 $as_echo "no" >&6; }
53040 53040 cat $FIXPATH_DIR/fixpath2.log
53041 53041 as_fn_error $? "fixpath did not work!" "$LINENO" 5
53042 53042 fi
53043 53043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
53044 53044 $as_echo "yes" >&6; }
53045 53045
53046 53046 FIXPATH_DETACH_FLAG="--detach"
53047 53047 fi
53048 53048
53049 53049
53050 53050
53051 53051
53052 53052
53053 53053
53054 53054 # Check if X11 is needed
53055 53055 if test "x$OPENJDK_TARGET_OS" = xwindows || test "x$OPENJDK_TARGET_OS" = xmacosx; then
53056 53056 # No X11 support on windows or macosx
53057 53057 NEEDS_LIB_X11=false
53058 53058 else
53059 53059 if test "x$SUPPORT_HEADFUL" = xno; then
53060 53060 # No X11 support if building headless-only
53061 53061 NEEDS_LIB_X11=false
53062 53062 else
53063 53063 # All other instances need X11
53064 53064 NEEDS_LIB_X11=true
53065 53065 fi
53066 53066 fi
53067 53067
53068 53068 # Check if cups is needed
53069 53069 if test "x$OPENJDK_TARGET_OS" = xwindows; then
53070 53070 # Windows have a separate print system
53071 53071 NEEDS_LIB_CUPS=false
53072 53072 else
53073 53073 NEEDS_LIB_CUPS=true
53074 53074 fi
53075 53075
53076 53076 # A custom hook may have set this already
53077 53077 if test "x$NEEDS_LIB_FREETYPE" = "x"; then
53078 53078 NEEDS_LIB_FREETYPE=true
53079 53079 fi
53080 53080
53081 53081 # Check if alsa is needed
53082 53082 if test "x$OPENJDK_TARGET_OS" = xlinux; then
53083 53083 NEEDS_LIB_ALSA=true
53084 53084 else
53085 53085 NEEDS_LIB_ALSA=false
53086 53086 fi
53087 53087
53088 53088 # Check if ffi is needed
53089 53089 if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
53090 53090 NEEDS_LIB_FFI=true
53091 53091 else
53092 53092 NEEDS_LIB_FFI=false
53093 53093 fi
53094 53094
53095 53095
53096 53096 # statically link libstdc++ before C++ ABI is stablized on Linux unless
53097 53097 # dynamic build is configured on command line.
53098 53098
53099 53099 # Check whether --with-stdc++lib was given.
53100 53100 if test "${with_stdc__lib+set}" = set; then :
53101 53101 withval=$with_stdc__lib;
53102 53102 if test "x$with_stdc__lib" != xdynamic && test "x$with_stdc__lib" != xstatic \
53103 53103 && test "x$with_stdc__lib" != xdefault; then
53104 53104 as_fn_error $? "Bad parameter value --with-stdc++lib=$with_stdc__lib!" "$LINENO" 5
53105 53105 fi
53106 53106
53107 53107 else
53108 53108 with_stdc__lib=default
53109 53109
53110 53110 fi
53111 53111
53112 53112
53113 53113 if test "x$OPENJDK_TARGET_OS" = xlinux; then
53114 53114 # Test if -lstdc++ works.
53115 53115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5
53116 53116 $as_echo_n "checking if dynamic link of stdc++ is possible... " >&6; }
53117 53117 ac_ext=cpp
53118 53118 ac_cpp='$CXXCPP $CPPFLAGS'
53119 53119 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
53120 53120 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
53121 53121 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
53122 53122
53123 53123 OLD_CXXFLAGS="$CXXFLAGS"
53124 53124 CXXFLAGS="$CXXFLAGS -lstdc++"
53125 53125 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
53126 53126 /* end confdefs.h. */
53127 53127
53128 53128 int
53129 53129 main ()
53130 53130 {
53131 53131 return 0;
53132 53132 ;
53133 53133 return 0;
53134 53134 }
53135 53135 _ACEOF
53136 53136 if ac_fn_cxx_try_link "$LINENO"; then :
53137 53137 has_dynamic_libstdcxx=yes
53138 53138 else
53139 53139 has_dynamic_libstdcxx=no
53140 53140 fi
53141 53141 rm -f core conftest.err conftest.$ac_objext \
53142 53142 conftest$ac_exeext conftest.$ac_ext
53143 53143 CXXFLAGS="$OLD_CXXFLAGS"
53144 53144 ac_ext=cpp
53145 53145 ac_cpp='$CXXCPP $CPPFLAGS'
53146 53146 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
53147 53147 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
53148 53148 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
53149 53149
53150 53150 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5
53151 53151 $as_echo "$has_dynamic_libstdcxx" >&6; }
53152 53152
53153 53153 # Test if stdc++ can be linked statically.
53154 53154 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
53155 53155 $as_echo_n "checking if static link of stdc++ is possible... " >&6; }
53156 53156 STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic"
53157 53157 ac_ext=cpp
53158 53158 ac_cpp='$CXXCPP $CPPFLAGS'
53159 53159 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
53160 53160 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
53161 53161 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
53162 53162
53163 53163 OLD_LIBS="$LIBS"
53164 53164 OLD_CXX="$CXX"
53165 53165 LIBS="$STATIC_STDCXX_FLAGS"
53166 53166 CXX="$CC"
53167 53167 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
53168 53168 /* end confdefs.h. */
53169 53169
53170 53170 int
53171 53171 main ()
53172 53172 {
53173 53173 return 0;
53174 53174 ;
53175 53175 return 0;
53176 53176 }
53177 53177 _ACEOF
53178 53178 if ac_fn_cxx_try_link "$LINENO"; then :
53179 53179 has_static_libstdcxx=yes
53180 53180 else
53181 53181 has_static_libstdcxx=no
53182 53182 fi
53183 53183 rm -f core conftest.err conftest.$ac_objext \
53184 53184 conftest$ac_exeext conftest.$ac_ext
53185 53185 LIBS="$OLD_LIBS"
53186 53186 CXX="$OLD_CXX"
53187 53187 ac_ext=cpp
53188 53188 ac_cpp='$CXXCPP $CPPFLAGS'
53189 53189 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
53190 53190 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
53191 53191 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
53192 53192
53193 53193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
53194 53194 $as_echo "$has_static_libstdcxx" >&6; }
53195 53195
53196 53196 if test "x$has_static_libstdcxx" = xno && test "x$has_dynamic_libstdcxx" = xno; then
53197 53197 as_fn_error $? "Cannot link to stdc++, neither dynamically nor statically!" "$LINENO" 5
53198 53198 fi
53199 53199
53200 53200 if test "x$with_stdc__lib" = xstatic && test "x$has_static_libstdcxx" = xno; then
53201 53201 as_fn_error $? "Static linking of libstdc++ was not possible!" "$LINENO" 5
53202 53202 fi
53203 53203
53204 53204 if test "x$with_stdc__lib" = xdynamic && test "x$has_dynamic_libstdcxx" = xno; then
53205 53205 as_fn_error $? "Dynamic linking of libstdc++ was not possible!" "$LINENO" 5
53206 53206 fi
53207 53207
53208 53208 # If dynamic was requested, it's available since it would fail above otherwise.
53209 53209 # If dynamic wasn't requested, go with static unless it isn't available.
53210 53210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
53211 53211 $as_echo_n "checking how to link with libstdc++... " >&6; }
53212 53212 if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
53213 53213 LIBCXX="$LIBCXX -lstdc++"
53214 53214 # To help comparisons with old build, put stdc++ first in JVM_LIBS
53215 53215 JVM_LIBS="-lstdc++ $JVM_LIBS"
53216 53216 # Ideally, we should test stdc++ for the BUILD toolchain separately. For now
53217 53217 # just use the same setting as for the TARGET toolchain.
53218 53218 OPENJDK_BUILD_JVM_LIBS="-lstdc++ $OPENJDK_BUILD_JVM_LIBS"
53219 53219 LDCXX="$CXX"
53220 53220 STATIC_CXX_SETTING="STATIC_CXX=false"
53221 53221 { $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
53222 53222 $as_echo "dynamic" >&6; }
53223 53223 else
53224 53224 LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS"
53225 53225 JVM_LDFLAGS="$JVM_LDFLAGS -static-libgcc"
53226 53226 # To help comparisons with old build, put stdc++ first in JVM_LIBS
53227 53227 JVM_LIBS="-Wl,-Bstatic -lstdc++ -Wl,-Bdynamic $JVM_LIBS"
53228 53228 # Ideally, we should test stdc++ for the BUILD toolchain separately. For now
53229 53229 # just use the same setting as for the TARGET toolchain.
53230 53230 OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -static-libgcc"
53231 53231 OPENJDK_BUILD_JVM_LIBS="-Wl,-Bstatic -lstdc++ -Wl,-Bdynamic $OPENJDK_BUILD_JVM_LIBS"
53232 53232 LDCXX="$CC"
53233 53233 STATIC_CXX_SETTING="STATIC_CXX=true"
53234 53234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5
53235 53235 $as_echo "static" >&6; }
53236 53236 fi
53237 53237 fi
53238 53238
53239 53239
53240 53240 # libCrun is the c++ runtime-library with SunStudio (roughly the equivalent of gcc's libstdc++.so)
53241 53241 if test "x$TOOLCHAIN_TYPE" = xsolstudio && test "x$LIBCXX" = x; then
53242 53242 LIBCXX="${SYSROOT}/usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libCrun.so.1"
53243 53243 fi
53244 53244
53245 53245 # TODO better (platform agnostic) test
53246 53246 if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$TOOLCHAIN_TYPE" = xgcc; then
53247 53247 LIBCXX="-lstdc++"
53248 53248 fi
53249 53249
53250 53250
53251 53251 # Setup Windows runtime dlls
53252 53252 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
53253 53253
53254 53254
53255 53255 # Check whether --with-msvcr-dll was given.
53256 53256 if test "${with_msvcr_dll+set}" = set; then :
53257 53257 withval=$with_msvcr_dll;
53258 53258 fi
53259 53259
53260 53260
53261 53261 if test "x$with_msvcr_dll" != x; then
53262 53262 # If given explicitely by user, do not probe. If not present, fail directly.
53263 53263
53264 53264 DLL_NAME="$MSVCR_NAME"
53265 53265 POSSIBLE_MSVC_DLL="$with_msvcr_dll"
53266 53266 METHOD="--with-msvcr-dll"
53267 53267 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
53268 53268 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
53269 53269 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
53270 53270
53271 53271 # Need to check if the found msvcr is correct architecture
53272 53272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
53273 53273 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
53274 53274 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
53275 53275 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53276 53276 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
53277 53277 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
53278 53278 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53279 53279 CORRECT_MSVCR_ARCH="PE32 executable"
53280 53280 else
53281 53281 CORRECT_MSVCR_ARCH="PE32+ executable"
53282 53282 fi
53283 53283 else
53284 53284 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53285 53285 CORRECT_MSVCR_ARCH=386
53286 53286 else
53287 53287 CORRECT_MSVCR_ARCH=x86-64
53288 53288 fi
53289 53289 fi
53290 53290 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
53291 53291 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
53292 53292 $as_echo "ok" >&6; }
53293 53293 MSVC_DLL="$POSSIBLE_MSVC_DLL"
53294 53294
53295 53295 # Only process if variable expands to non-empty
53296 53296
53297 53297 if test "x$MSVC_DLL" != x; then
53298 53298 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53299 53299
53300 53300 # Input might be given as Windows format, start by converting to
53301 53301 # unix format.
53302 53302 path="$MSVC_DLL"
53303 53303 new_path=`$CYGPATH -u "$path"`
53304 53304
53305 53305 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
53306 53306 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
53307 53307 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
53308 53308 # "foo.exe" is OK but "foo" is an error.
53309 53309 #
53310 53310 # This test is therefore slightly more accurate than "test -f" to check for file precense.
53311 53311 # It is also a way to make sure we got the proper file name for the real test later on.
53312 53312 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
53313 53313 if test "x$test_shortpath" = x; then
53314 53314 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53315 53315 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53316 53316 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
53317 53317 fi
53318 53318
53319 53319 # Call helper function which possibly converts this using DOS-style short mode.
53320 53320 # If so, the updated path is stored in $new_path.
53321 53321
53322 53322 input_path="$new_path"
53323 53323 # Check if we need to convert this using DOS-style short mode. If the path
53324 53324 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53325 53325 # take no chances and rewrite it.
53326 53326 # Note: m4 eats our [], so we need to use [ and ] instead.
53327 53327 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
53328 53328 if test "x$has_forbidden_chars" != x; then
53329 53329 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53330 53330 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
53331 53331 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
53332 53332 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
53333 53333 # Going to short mode and back again did indeed matter. Since short mode is
53334 53334 # case insensitive, let's make it lowercase to improve readability.
53335 53335 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53336 53336 # Now convert it back to Unix-style (cygpath)
53337 53337 input_path=`$CYGPATH -u "$shortmode_path"`
53338 53338 new_path="$input_path"
53339 53339 fi
53340 53340 fi
53341 53341
53342 53342 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
53343 53343 if test "x$test_cygdrive_prefix" = x; then
53344 53344 # As a simple fix, exclude /usr/bin since it's not a real path.
53345 53345 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
53346 53346 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
53347 53347 # a path prefixed by /cygdrive for fixpath to work.
53348 53348 new_path="$CYGWIN_ROOT_PATH$input_path"
53349 53349 fi
53350 53350 fi
53351 53351
53352 53352
53353 53353 if test "x$path" != "x$new_path"; then
53354 53354 MSVC_DLL="$new_path"
53355 53355 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53356 53356 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53357 53357 fi
53358 53358
53359 53359 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53360 53360
53361 53361 path="$MSVC_DLL"
53362 53362 has_colon=`$ECHO $path | $GREP ^.:`
53363 53363 new_path="$path"
53364 53364 if test "x$has_colon" = x; then
53365 53365 # Not in mixed or Windows style, start by that.
53366 53366 new_path=`cmd //c echo $path`
53367 53367 fi
53368 53368
53369 53369
53370 53370 input_path="$new_path"
53371 53371 # Check if we need to convert this using DOS-style short mode. If the path
53372 53372 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53373 53373 # take no chances and rewrite it.
53374 53374 # Note: m4 eats our [], so we need to use [ and ] instead.
53375 53375 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
53376 53376 if test "x$has_forbidden_chars" != x; then
53377 53377 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53378 53378 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53379 53379 fi
53380 53380
53381 53381
53382 53382 windows_path="$new_path"
53383 53383 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53384 53384 unix_path=`$CYGPATH -u "$windows_path"`
53385 53385 new_path="$unix_path"
53386 53386 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53387 53387 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
53388 53388 new_path="$unix_path"
53389 53389 fi
53390 53390
53391 53391 if test "x$path" != "x$new_path"; then
53392 53392 MSVC_DLL="$new_path"
53393 53393 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53394 53394 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53395 53395 fi
53396 53396
53397 53397 # Save the first 10 bytes of this path to the storage, so fixpath can work.
53398 53398 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
53399 53399
53400 53400 else
53401 53401 # We're on a unix platform. Hooray! :)
53402 53402 path="$MSVC_DLL"
53403 53403 has_space=`$ECHO "$path" | $GREP " "`
53404 53404 if test "x$has_space" != x; then
53405 53405 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53406 53406 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53407 53407 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
53408 53408 fi
53409 53409
53410 53410 # Use eval to expand a potential ~
53411 53411 eval path="$path"
53412 53412 if test ! -f "$path" && test ! -d "$path"; then
53413 53413 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
53414 53414 fi
53415 53415
53416 53416 if test -d "$path"; then
53417 53417 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
53418 53418 else
53419 53419 dir="`$DIRNAME "$path"`"
53420 53420 base="`$BASENAME "$path"`"
53421 53421 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
53422 53422 fi
53423 53423 fi
53424 53424 fi
53425 53425
53426 53426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
53427 53427 $as_echo_n "checking for $DLL_NAME... " >&6; }
53428 53428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
53429 53429 $as_echo "$MSVC_DLL" >&6; }
53430 53430 else
53431 53431 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
53432 53432 $as_echo "incorrect, ignoring" >&6; }
53433 53433 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
53434 53434 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
53435 53435 fi
53436 53436 fi
53437 53437
53438 53438 if test "x$MSVC_DLL" = x; then
53439 53439 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5
53440 53440 fi
53441 53441 MSVCR_DLL="$MSVC_DLL"
53442 53442 elif test "x$DEVKIT_MSVCR_DLL" != x; then
53443 53443
53444 53444 DLL_NAME="$MSVCR_NAME"
53445 53445 POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL"
53446 53446 METHOD="devkit"
53447 53447 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
53448 53448 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
53449 53449 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
53450 53450
53451 53451 # Need to check if the found msvcr is correct architecture
53452 53452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
53453 53453 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
53454 53454 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
53455 53455 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53456 53456 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
53457 53457 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
53458 53458 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53459 53459 CORRECT_MSVCR_ARCH="PE32 executable"
53460 53460 else
53461 53461 CORRECT_MSVCR_ARCH="PE32+ executable"
53462 53462 fi
53463 53463 else
53464 53464 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53465 53465 CORRECT_MSVCR_ARCH=386
53466 53466 else
53467 53467 CORRECT_MSVCR_ARCH=x86-64
53468 53468 fi
53469 53469 fi
53470 53470 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
53471 53471 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
53472 53472 $as_echo "ok" >&6; }
53473 53473 MSVC_DLL="$POSSIBLE_MSVC_DLL"
53474 53474
53475 53475 # Only process if variable expands to non-empty
53476 53476
53477 53477 if test "x$MSVC_DLL" != x; then
53478 53478 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53479 53479
53480 53480 # Input might be given as Windows format, start by converting to
53481 53481 # unix format.
53482 53482 path="$MSVC_DLL"
53483 53483 new_path=`$CYGPATH -u "$path"`
53484 53484
53485 53485 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
53486 53486 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
53487 53487 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
53488 53488 # "foo.exe" is OK but "foo" is an error.
53489 53489 #
53490 53490 # This test is therefore slightly more accurate than "test -f" to check for file precense.
53491 53491 # It is also a way to make sure we got the proper file name for the real test later on.
53492 53492 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
53493 53493 if test "x$test_shortpath" = x; then
53494 53494 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53495 53495 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53496 53496 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
53497 53497 fi
53498 53498
53499 53499 # Call helper function which possibly converts this using DOS-style short mode.
53500 53500 # If so, the updated path is stored in $new_path.
53501 53501
53502 53502 input_path="$new_path"
53503 53503 # Check if we need to convert this using DOS-style short mode. If the path
53504 53504 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53505 53505 # take no chances and rewrite it.
53506 53506 # Note: m4 eats our [], so we need to use [ and ] instead.
53507 53507 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
53508 53508 if test "x$has_forbidden_chars" != x; then
53509 53509 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53510 53510 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
53511 53511 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
53512 53512 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
53513 53513 # Going to short mode and back again did indeed matter. Since short mode is
53514 53514 # case insensitive, let's make it lowercase to improve readability.
53515 53515 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53516 53516 # Now convert it back to Unix-style (cygpath)
53517 53517 input_path=`$CYGPATH -u "$shortmode_path"`
53518 53518 new_path="$input_path"
53519 53519 fi
53520 53520 fi
53521 53521
53522 53522 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
53523 53523 if test "x$test_cygdrive_prefix" = x; then
53524 53524 # As a simple fix, exclude /usr/bin since it's not a real path.
53525 53525 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
53526 53526 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
53527 53527 # a path prefixed by /cygdrive for fixpath to work.
53528 53528 new_path="$CYGWIN_ROOT_PATH$input_path"
53529 53529 fi
53530 53530 fi
53531 53531
53532 53532
53533 53533 if test "x$path" != "x$new_path"; then
53534 53534 MSVC_DLL="$new_path"
53535 53535 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53536 53536 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53537 53537 fi
53538 53538
53539 53539 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53540 53540
53541 53541 path="$MSVC_DLL"
53542 53542 has_colon=`$ECHO $path | $GREP ^.:`
53543 53543 new_path="$path"
53544 53544 if test "x$has_colon" = x; then
53545 53545 # Not in mixed or Windows style, start by that.
53546 53546 new_path=`cmd //c echo $path`
53547 53547 fi
53548 53548
53549 53549
53550 53550 input_path="$new_path"
53551 53551 # Check if we need to convert this using DOS-style short mode. If the path
53552 53552 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53553 53553 # take no chances and rewrite it.
53554 53554 # Note: m4 eats our [], so we need to use [ and ] instead.
53555 53555 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
53556 53556 if test "x$has_forbidden_chars" != x; then
53557 53557 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53558 53558 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53559 53559 fi
53560 53560
53561 53561
53562 53562 windows_path="$new_path"
53563 53563 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53564 53564 unix_path=`$CYGPATH -u "$windows_path"`
53565 53565 new_path="$unix_path"
53566 53566 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53567 53567 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
53568 53568 new_path="$unix_path"
53569 53569 fi
53570 53570
53571 53571 if test "x$path" != "x$new_path"; then
53572 53572 MSVC_DLL="$new_path"
53573 53573 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53574 53574 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53575 53575 fi
53576 53576
53577 53577 # Save the first 10 bytes of this path to the storage, so fixpath can work.
53578 53578 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
53579 53579
53580 53580 else
53581 53581 # We're on a unix platform. Hooray! :)
53582 53582 path="$MSVC_DLL"
53583 53583 has_space=`$ECHO "$path" | $GREP " "`
53584 53584 if test "x$has_space" != x; then
53585 53585 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53586 53586 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53587 53587 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
53588 53588 fi
53589 53589
53590 53590 # Use eval to expand a potential ~
53591 53591 eval path="$path"
53592 53592 if test ! -f "$path" && test ! -d "$path"; then
53593 53593 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
53594 53594 fi
53595 53595
53596 53596 if test -d "$path"; then
53597 53597 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
53598 53598 else
53599 53599 dir="`$DIRNAME "$path"`"
53600 53600 base="`$BASENAME "$path"`"
53601 53601 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
53602 53602 fi
53603 53603 fi
53604 53604 fi
53605 53605
53606 53606 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
53607 53607 $as_echo_n "checking for $DLL_NAME... " >&6; }
53608 53608 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
53609 53609 $as_echo "$MSVC_DLL" >&6; }
53610 53610 else
53611 53611 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
53612 53612 $as_echo "incorrect, ignoring" >&6; }
53613 53613 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
53614 53614 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
53615 53615 fi
53616 53616 fi
53617 53617
53618 53618 if test "x$MSVC_DLL" = x; then
53619 53619 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by devkit" "$LINENO" 5
53620 53620 fi
53621 53621 MSVCR_DLL="$MSVC_DLL"
53622 53622 else
53623 53623
53624 53624 DLL_NAME="${MSVCR_NAME}"
53625 53625 MSVC_DLL=
53626 53626
53627 53627 if test "x$MSVC_DLL" = x; then
53628 53628 # Probe: Using well-known location from Visual Studio 10.0
53629 53629 if test "x$VCINSTALLDIR" != x; then
53630 53630 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
53631 53631
53632 53632 windows_path="$CYGWIN_VC_INSTALL_DIR"
53633 53633 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53634 53634 unix_path=`$CYGPATH -u "$windows_path"`
53635 53635 CYGWIN_VC_INSTALL_DIR="$unix_path"
53636 53636 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53637 53637 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
53638 53638 CYGWIN_VC_INSTALL_DIR="$unix_path"
53639 53639 fi
53640 53640
53641 53641 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
53642 53642 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
53643 53643 else
53644 53644 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
53645 53645 fi
53646 53646 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
53647 53647
53648 53648 DLL_NAME="$DLL_NAME"
53649 53649 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
53650 53650 METHOD="well-known location in VCINSTALLDIR"
53651 53651 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
53652 53652 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
53653 53653 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
53654 53654
53655 53655 # Need to check if the found msvcr is correct architecture
53656 53656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
53657 53657 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
53658 53658 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
53659 53659 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53660 53660 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
53661 53661 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
53662 53662 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53663 53663 CORRECT_MSVCR_ARCH="PE32 executable"
53664 53664 else
53665 53665 CORRECT_MSVCR_ARCH="PE32+ executable"
53666 53666 fi
53667 53667 else
53668 53668 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53669 53669 CORRECT_MSVCR_ARCH=386
53670 53670 else
53671 53671 CORRECT_MSVCR_ARCH=x86-64
53672 53672 fi
53673 53673 fi
53674 53674 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
53675 53675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
53676 53676 $as_echo "ok" >&6; }
53677 53677 MSVC_DLL="$POSSIBLE_MSVC_DLL"
53678 53678
53679 53679 # Only process if variable expands to non-empty
53680 53680
53681 53681 if test "x$MSVC_DLL" != x; then
53682 53682 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53683 53683
53684 53684 # Input might be given as Windows format, start by converting to
53685 53685 # unix format.
53686 53686 path="$MSVC_DLL"
53687 53687 new_path=`$CYGPATH -u "$path"`
53688 53688
53689 53689 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
53690 53690 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
53691 53691 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
53692 53692 # "foo.exe" is OK but "foo" is an error.
53693 53693 #
53694 53694 # This test is therefore slightly more accurate than "test -f" to check for file precense.
53695 53695 # It is also a way to make sure we got the proper file name for the real test later on.
53696 53696 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
53697 53697 if test "x$test_shortpath" = x; then
53698 53698 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53699 53699 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53700 53700 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
53701 53701 fi
53702 53702
53703 53703 # Call helper function which possibly converts this using DOS-style short mode.
53704 53704 # If so, the updated path is stored in $new_path.
53705 53705
53706 53706 input_path="$new_path"
53707 53707 # Check if we need to convert this using DOS-style short mode. If the path
53708 53708 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53709 53709 # take no chances and rewrite it.
53710 53710 # Note: m4 eats our [], so we need to use [ and ] instead.
53711 53711 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
53712 53712 if test "x$has_forbidden_chars" != x; then
53713 53713 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53714 53714 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
53715 53715 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
53716 53716 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
53717 53717 # Going to short mode and back again did indeed matter. Since short mode is
53718 53718 # case insensitive, let's make it lowercase to improve readability.
53719 53719 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53720 53720 # Now convert it back to Unix-style (cygpath)
53721 53721 input_path=`$CYGPATH -u "$shortmode_path"`
53722 53722 new_path="$input_path"
53723 53723 fi
53724 53724 fi
53725 53725
53726 53726 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
53727 53727 if test "x$test_cygdrive_prefix" = x; then
53728 53728 # As a simple fix, exclude /usr/bin since it's not a real path.
53729 53729 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
53730 53730 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
53731 53731 # a path prefixed by /cygdrive for fixpath to work.
53732 53732 new_path="$CYGWIN_ROOT_PATH$input_path"
53733 53733 fi
53734 53734 fi
53735 53735
53736 53736
53737 53737 if test "x$path" != "x$new_path"; then
53738 53738 MSVC_DLL="$new_path"
53739 53739 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53740 53740 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53741 53741 fi
53742 53742
53743 53743 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53744 53744
53745 53745 path="$MSVC_DLL"
53746 53746 has_colon=`$ECHO $path | $GREP ^.:`
53747 53747 new_path="$path"
53748 53748 if test "x$has_colon" = x; then
53749 53749 # Not in mixed or Windows style, start by that.
53750 53750 new_path=`cmd //c echo $path`
53751 53751 fi
53752 53752
53753 53753
53754 53754 input_path="$new_path"
53755 53755 # Check if we need to convert this using DOS-style short mode. If the path
53756 53756 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53757 53757 # take no chances and rewrite it.
53758 53758 # Note: m4 eats our [], so we need to use [ and ] instead.
53759 53759 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
53760 53760 if test "x$has_forbidden_chars" != x; then
53761 53761 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53762 53762 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53763 53763 fi
53764 53764
53765 53765
53766 53766 windows_path="$new_path"
53767 53767 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53768 53768 unix_path=`$CYGPATH -u "$windows_path"`
53769 53769 new_path="$unix_path"
53770 53770 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53771 53771 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
53772 53772 new_path="$unix_path"
53773 53773 fi
53774 53774
53775 53775 if test "x$path" != "x$new_path"; then
53776 53776 MSVC_DLL="$new_path"
53777 53777 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53778 53778 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53779 53779 fi
53780 53780
53781 53781 # Save the first 10 bytes of this path to the storage, so fixpath can work.
53782 53782 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
53783 53783
53784 53784 else
53785 53785 # We're on a unix platform. Hooray! :)
53786 53786 path="$MSVC_DLL"
53787 53787 has_space=`$ECHO "$path" | $GREP " "`
53788 53788 if test "x$has_space" != x; then
53789 53789 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53790 53790 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53791 53791 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
53792 53792 fi
53793 53793
53794 53794 # Use eval to expand a potential ~
53795 53795 eval path="$path"
53796 53796 if test ! -f "$path" && test ! -d "$path"; then
53797 53797 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
53798 53798 fi
53799 53799
53800 53800 if test -d "$path"; then
53801 53801 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
53802 53802 else
53803 53803 dir="`$DIRNAME "$path"`"
53804 53804 base="`$BASENAME "$path"`"
53805 53805 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
53806 53806 fi
53807 53807 fi
53808 53808 fi
53809 53809
53810 53810 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
53811 53811 $as_echo_n "checking for $DLL_NAME... " >&6; }
53812 53812 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
53813 53813 $as_echo "$MSVC_DLL" >&6; }
53814 53814 else
53815 53815 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
53816 53816 $as_echo "incorrect, ignoring" >&6; }
53817 53817 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
53818 53818 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
53819 53819 fi
53820 53820 fi
53821 53821
53822 53822 fi
53823 53823 fi
53824 53824
53825 53825 if test "x$MSVC_DLL" = x; then
53826 53826 # Probe: Check in the Boot JDK directory.
53827 53827 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
53828 53828
53829 53829 DLL_NAME="$DLL_NAME"
53830 53830 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
53831 53831 METHOD="well-known location in Boot JDK"
53832 53832 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
53833 53833 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
53834 53834 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
53835 53835
53836 53836 # Need to check if the found msvcr is correct architecture
53837 53837 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
53838 53838 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
53839 53839 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
53840 53840 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53841 53841 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
53842 53842 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
53843 53843 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53844 53844 CORRECT_MSVCR_ARCH="PE32 executable"
53845 53845 else
53846 53846 CORRECT_MSVCR_ARCH="PE32+ executable"
53847 53847 fi
53848 53848 else
53849 53849 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
53850 53850 CORRECT_MSVCR_ARCH=386
53851 53851 else
53852 53852 CORRECT_MSVCR_ARCH=x86-64
53853 53853 fi
53854 53854 fi
53855 53855 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
53856 53856 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
53857 53857 $as_echo "ok" >&6; }
53858 53858 MSVC_DLL="$POSSIBLE_MSVC_DLL"
53859 53859
53860 53860 # Only process if variable expands to non-empty
53861 53861
53862 53862 if test "x$MSVC_DLL" != x; then
53863 53863 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53864 53864
53865 53865 # Input might be given as Windows format, start by converting to
53866 53866 # unix format.
53867 53867 path="$MSVC_DLL"
53868 53868 new_path=`$CYGPATH -u "$path"`
53869 53869
53870 53870 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
53871 53871 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
53872 53872 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
53873 53873 # "foo.exe" is OK but "foo" is an error.
53874 53874 #
53875 53875 # This test is therefore slightly more accurate than "test -f" to check for file precense.
53876 53876 # It is also a way to make sure we got the proper file name for the real test later on.
53877 53877 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
53878 53878 if test "x$test_shortpath" = x; then
53879 53879 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53880 53880 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53881 53881 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
53882 53882 fi
53883 53883
53884 53884 # Call helper function which possibly converts this using DOS-style short mode.
53885 53885 # If so, the updated path is stored in $new_path.
53886 53886
53887 53887 input_path="$new_path"
53888 53888 # Check if we need to convert this using DOS-style short mode. If the path
53889 53889 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53890 53890 # take no chances and rewrite it.
53891 53891 # Note: m4 eats our [], so we need to use [ and ] instead.
53892 53892 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
53893 53893 if test "x$has_forbidden_chars" != x; then
53894 53894 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53895 53895 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
53896 53896 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
53897 53897 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
53898 53898 # Going to short mode and back again did indeed matter. Since short mode is
53899 53899 # case insensitive, let's make it lowercase to improve readability.
53900 53900 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53901 53901 # Now convert it back to Unix-style (cygpath)
53902 53902 input_path=`$CYGPATH -u "$shortmode_path"`
53903 53903 new_path="$input_path"
53904 53904 fi
53905 53905 fi
53906 53906
53907 53907 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
53908 53908 if test "x$test_cygdrive_prefix" = x; then
53909 53909 # As a simple fix, exclude /usr/bin since it's not a real path.
53910 53910 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
53911 53911 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
53912 53912 # a path prefixed by /cygdrive for fixpath to work.
53913 53913 new_path="$CYGWIN_ROOT_PATH$input_path"
53914 53914 fi
53915 53915 fi
53916 53916
53917 53917
53918 53918 if test "x$path" != "x$new_path"; then
53919 53919 MSVC_DLL="$new_path"
53920 53920 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53921 53921 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53922 53922 fi
53923 53923
53924 53924 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53925 53925
53926 53926 path="$MSVC_DLL"
53927 53927 has_colon=`$ECHO $path | $GREP ^.:`
53928 53928 new_path="$path"
53929 53929 if test "x$has_colon" = x; then
53930 53930 # Not in mixed or Windows style, start by that.
53931 53931 new_path=`cmd //c echo $path`
53932 53932 fi
53933 53933
53934 53934
53935 53935 input_path="$new_path"
53936 53936 # Check if we need to convert this using DOS-style short mode. If the path
53937 53937 # contains just simple characters, use it. Otherwise (spaces, weird characters),
53938 53938 # take no chances and rewrite it.
53939 53939 # Note: m4 eats our [], so we need to use [ and ] instead.
53940 53940 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
53941 53941 if test "x$has_forbidden_chars" != x; then
53942 53942 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
53943 53943 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
53944 53944 fi
53945 53945
53946 53946
53947 53947 windows_path="$new_path"
53948 53948 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
53949 53949 unix_path=`$CYGPATH -u "$windows_path"`
53950 53950 new_path="$unix_path"
53951 53951 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
53952 53952 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
53953 53953 new_path="$unix_path"
53954 53954 fi
53955 53955
53956 53956 if test "x$path" != "x$new_path"; then
53957 53957 MSVC_DLL="$new_path"
53958 53958 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
53959 53959 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
53960 53960 fi
53961 53961
53962 53962 # Save the first 10 bytes of this path to the storage, so fixpath can work.
53963 53963 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
53964 53964
53965 53965 else
53966 53966 # We're on a unix platform. Hooray! :)
53967 53967 path="$MSVC_DLL"
53968 53968 has_space=`$ECHO "$path" | $GREP " "`
53969 53969 if test "x$has_space" != x; then
53970 53970 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
53971 53971 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
53972 53972 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
53973 53973 fi
53974 53974
53975 53975 # Use eval to expand a potential ~
53976 53976 eval path="$path"
53977 53977 if test ! -f "$path" && test ! -d "$path"; then
53978 53978 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
53979 53979 fi
53980 53980
53981 53981 if test -d "$path"; then
53982 53982 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
53983 53983 else
53984 53984 dir="`$DIRNAME "$path"`"
53985 53985 base="`$BASENAME "$path"`"
53986 53986 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
53987 53987 fi
53988 53988 fi
53989 53989 fi
53990 53990
53991 53991 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
53992 53992 $as_echo_n "checking for $DLL_NAME... " >&6; }
53993 53993 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
53994 53994 $as_echo "$MSVC_DLL" >&6; }
53995 53995 else
53996 53996 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
53997 53997 $as_echo "incorrect, ignoring" >&6; }
53998 53998 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
53999 53999 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54000 54000 fi
54001 54001 fi
54002 54002
54003 54003 fi
54004 54004
54005 54005 if test "x$MSVC_DLL" = x; then
54006 54006 # Probe: Look in the Windows system32 directory
54007 54007 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
54008 54008
54009 54009 windows_path="$CYGWIN_SYSTEMROOT"
54010 54010 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54011 54011 unix_path=`$CYGPATH -u "$windows_path"`
54012 54012 CYGWIN_SYSTEMROOT="$unix_path"
54013 54013 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54014 54014 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54015 54015 CYGWIN_SYSTEMROOT="$unix_path"
54016 54016 fi
54017 54017
54018 54018 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
54019 54019
54020 54020 DLL_NAME="$DLL_NAME"
54021 54021 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
54022 54022 METHOD="well-known location in SYSTEMROOT"
54023 54023 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
54024 54024 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
54025 54025 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
54026 54026
54027 54027 # Need to check if the found msvcr is correct architecture
54028 54028 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
54029 54029 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
54030 54030 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
54031 54031 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54032 54032 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
54033 54033 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
54034 54034 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54035 54035 CORRECT_MSVCR_ARCH="PE32 executable"
54036 54036 else
54037 54037 CORRECT_MSVCR_ARCH="PE32+ executable"
54038 54038 fi
54039 54039 else
54040 54040 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54041 54041 CORRECT_MSVCR_ARCH=386
54042 54042 else
54043 54043 CORRECT_MSVCR_ARCH=x86-64
54044 54044 fi
54045 54045 fi
54046 54046 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
54047 54047 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
54048 54048 $as_echo "ok" >&6; }
54049 54049 MSVC_DLL="$POSSIBLE_MSVC_DLL"
54050 54050
54051 54051 # Only process if variable expands to non-empty
54052 54052
54053 54053 if test "x$MSVC_DLL" != x; then
54054 54054 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54055 54055
54056 54056 # Input might be given as Windows format, start by converting to
54057 54057 # unix format.
54058 54058 path="$MSVC_DLL"
54059 54059 new_path=`$CYGPATH -u "$path"`
54060 54060
54061 54061 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
54062 54062 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
54063 54063 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
54064 54064 # "foo.exe" is OK but "foo" is an error.
54065 54065 #
54066 54066 # This test is therefore slightly more accurate than "test -f" to check for file precense.
54067 54067 # It is also a way to make sure we got the proper file name for the real test later on.
54068 54068 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
54069 54069 if test "x$test_shortpath" = x; then
54070 54070 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54071 54071 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54072 54072 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
54073 54073 fi
54074 54074
54075 54075 # Call helper function which possibly converts this using DOS-style short mode.
54076 54076 # If so, the updated path is stored in $new_path.
54077 54077
54078 54078 input_path="$new_path"
54079 54079 # Check if we need to convert this using DOS-style short mode. If the path
54080 54080 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54081 54081 # take no chances and rewrite it.
54082 54082 # Note: m4 eats our [], so we need to use [ and ] instead.
54083 54083 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
54084 54084 if test "x$has_forbidden_chars" != x; then
54085 54085 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54086 54086 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
54087 54087 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
54088 54088 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
54089 54089 # Going to short mode and back again did indeed matter. Since short mode is
54090 54090 # case insensitive, let's make it lowercase to improve readability.
54091 54091 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54092 54092 # Now convert it back to Unix-style (cygpath)
54093 54093 input_path=`$CYGPATH -u "$shortmode_path"`
54094 54094 new_path="$input_path"
54095 54095 fi
54096 54096 fi
54097 54097
54098 54098 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
54099 54099 if test "x$test_cygdrive_prefix" = x; then
54100 54100 # As a simple fix, exclude /usr/bin since it's not a real path.
54101 54101 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
54102 54102 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
54103 54103 # a path prefixed by /cygdrive for fixpath to work.
54104 54104 new_path="$CYGWIN_ROOT_PATH$input_path"
54105 54105 fi
54106 54106 fi
54107 54107
54108 54108
54109 54109 if test "x$path" != "x$new_path"; then
54110 54110 MSVC_DLL="$new_path"
54111 54111 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54112 54112 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54113 54113 fi
54114 54114
54115 54115 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54116 54116
54117 54117 path="$MSVC_DLL"
54118 54118 has_colon=`$ECHO $path | $GREP ^.:`
54119 54119 new_path="$path"
54120 54120 if test "x$has_colon" = x; then
54121 54121 # Not in mixed or Windows style, start by that.
54122 54122 new_path=`cmd //c echo $path`
54123 54123 fi
54124 54124
54125 54125
54126 54126 input_path="$new_path"
54127 54127 # Check if we need to convert this using DOS-style short mode. If the path
54128 54128 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54129 54129 # take no chances and rewrite it.
54130 54130 # Note: m4 eats our [], so we need to use [ and ] instead.
54131 54131 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
54132 54132 if test "x$has_forbidden_chars" != x; then
54133 54133 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54134 54134 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54135 54135 fi
54136 54136
54137 54137
54138 54138 windows_path="$new_path"
54139 54139 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54140 54140 unix_path=`$CYGPATH -u "$windows_path"`
54141 54141 new_path="$unix_path"
54142 54142 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54143 54143 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54144 54144 new_path="$unix_path"
54145 54145 fi
54146 54146
54147 54147 if test "x$path" != "x$new_path"; then
54148 54148 MSVC_DLL="$new_path"
54149 54149 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54150 54150 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54151 54151 fi
54152 54152
54153 54153 # Save the first 10 bytes of this path to the storage, so fixpath can work.
54154 54154 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
54155 54155
54156 54156 else
54157 54157 # We're on a unix platform. Hooray! :)
54158 54158 path="$MSVC_DLL"
54159 54159 has_space=`$ECHO "$path" | $GREP " "`
54160 54160 if test "x$has_space" != x; then
54161 54161 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54162 54162 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54163 54163 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
54164 54164 fi
54165 54165
54166 54166 # Use eval to expand a potential ~
54167 54167 eval path="$path"
54168 54168 if test ! -f "$path" && test ! -d "$path"; then
54169 54169 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
54170 54170 fi
54171 54171
54172 54172 if test -d "$path"; then
54173 54173 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
54174 54174 else
54175 54175 dir="`$DIRNAME "$path"`"
54176 54176 base="`$BASENAME "$path"`"
54177 54177 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
54178 54178 fi
54179 54179 fi
54180 54180 fi
54181 54181
54182 54182 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54183 54183 $as_echo_n "checking for $DLL_NAME... " >&6; }
54184 54184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
54185 54185 $as_echo "$MSVC_DLL" >&6; }
54186 54186 else
54187 54187 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
54188 54188 $as_echo "incorrect, ignoring" >&6; }
54189 54189 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
54190 54190 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54191 54191 fi
54192 54192 fi
54193 54193
54194 54194 fi
54195 54195
54196 54196 if test "x$MSVC_DLL" = x; then
54197 54197 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
54198 54198 if test "x$VS100COMNTOOLS" != x; then
54199 54199 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
54200 54200
54201 54201 windows_path="$CYGWIN_VS_TOOLS_DIR"
54202 54202 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54203 54203 unix_path=`$CYGPATH -u "$windows_path"`
54204 54204 CYGWIN_VS_TOOLS_DIR="$unix_path"
54205 54205 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54206 54206 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54207 54207 CYGWIN_VS_TOOLS_DIR="$unix_path"
54208 54208 fi
54209 54209
54210 54210 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
54211 54211 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
54212 54212 | $GREP -i /x64/ | $HEAD --lines 1`
54213 54213 else
54214 54214 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
54215 54215 | $GREP -i /x86/ | $HEAD --lines 1`
54216 54216 fi
54217 54217
54218 54218 DLL_NAME="$DLL_NAME"
54219 54219 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
54220 54220 METHOD="search of VS100COMNTOOLS"
54221 54221 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
54222 54222 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
54223 54223 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
54224 54224
54225 54225 # Need to check if the found msvcr is correct architecture
54226 54226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
54227 54227 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
54228 54228 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
54229 54229 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54230 54230 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
54231 54231 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
54232 54232 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54233 54233 CORRECT_MSVCR_ARCH="PE32 executable"
54234 54234 else
54235 54235 CORRECT_MSVCR_ARCH="PE32+ executable"
54236 54236 fi
54237 54237 else
54238 54238 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54239 54239 CORRECT_MSVCR_ARCH=386
54240 54240 else
54241 54241 CORRECT_MSVCR_ARCH=x86-64
54242 54242 fi
54243 54243 fi
54244 54244 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
54245 54245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
54246 54246 $as_echo "ok" >&6; }
54247 54247 MSVC_DLL="$POSSIBLE_MSVC_DLL"
54248 54248
54249 54249 # Only process if variable expands to non-empty
54250 54250
54251 54251 if test "x$MSVC_DLL" != x; then
54252 54252 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54253 54253
54254 54254 # Input might be given as Windows format, start by converting to
54255 54255 # unix format.
54256 54256 path="$MSVC_DLL"
54257 54257 new_path=`$CYGPATH -u "$path"`
54258 54258
54259 54259 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
54260 54260 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
54261 54261 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
54262 54262 # "foo.exe" is OK but "foo" is an error.
54263 54263 #
54264 54264 # This test is therefore slightly more accurate than "test -f" to check for file precense.
54265 54265 # It is also a way to make sure we got the proper file name for the real test later on.
54266 54266 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
54267 54267 if test "x$test_shortpath" = x; then
54268 54268 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54269 54269 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54270 54270 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
54271 54271 fi
54272 54272
54273 54273 # Call helper function which possibly converts this using DOS-style short mode.
54274 54274 # If so, the updated path is stored in $new_path.
54275 54275
54276 54276 input_path="$new_path"
54277 54277 # Check if we need to convert this using DOS-style short mode. If the path
54278 54278 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54279 54279 # take no chances and rewrite it.
54280 54280 # Note: m4 eats our [], so we need to use [ and ] instead.
54281 54281 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
54282 54282 if test "x$has_forbidden_chars" != x; then
54283 54283 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54284 54284 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
54285 54285 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
54286 54286 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
54287 54287 # Going to short mode and back again did indeed matter. Since short mode is
54288 54288 # case insensitive, let's make it lowercase to improve readability.
54289 54289 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54290 54290 # Now convert it back to Unix-style (cygpath)
54291 54291 input_path=`$CYGPATH -u "$shortmode_path"`
54292 54292 new_path="$input_path"
54293 54293 fi
54294 54294 fi
54295 54295
54296 54296 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
54297 54297 if test "x$test_cygdrive_prefix" = x; then
54298 54298 # As a simple fix, exclude /usr/bin since it's not a real path.
54299 54299 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
54300 54300 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
54301 54301 # a path prefixed by /cygdrive for fixpath to work.
54302 54302 new_path="$CYGWIN_ROOT_PATH$input_path"
54303 54303 fi
54304 54304 fi
54305 54305
54306 54306
54307 54307 if test "x$path" != "x$new_path"; then
54308 54308 MSVC_DLL="$new_path"
54309 54309 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54310 54310 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54311 54311 fi
54312 54312
54313 54313 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54314 54314
54315 54315 path="$MSVC_DLL"
54316 54316 has_colon=`$ECHO $path | $GREP ^.:`
54317 54317 new_path="$path"
54318 54318 if test "x$has_colon" = x; then
54319 54319 # Not in mixed or Windows style, start by that.
54320 54320 new_path=`cmd //c echo $path`
54321 54321 fi
54322 54322
54323 54323
54324 54324 input_path="$new_path"
54325 54325 # Check if we need to convert this using DOS-style short mode. If the path
54326 54326 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54327 54327 # take no chances and rewrite it.
54328 54328 # Note: m4 eats our [], so we need to use [ and ] instead.
54329 54329 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
54330 54330 if test "x$has_forbidden_chars" != x; then
54331 54331 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54332 54332 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54333 54333 fi
54334 54334
54335 54335
54336 54336 windows_path="$new_path"
54337 54337 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54338 54338 unix_path=`$CYGPATH -u "$windows_path"`
54339 54339 new_path="$unix_path"
54340 54340 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54341 54341 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54342 54342 new_path="$unix_path"
54343 54343 fi
54344 54344
54345 54345 if test "x$path" != "x$new_path"; then
54346 54346 MSVC_DLL="$new_path"
54347 54347 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54348 54348 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54349 54349 fi
54350 54350
54351 54351 # Save the first 10 bytes of this path to the storage, so fixpath can work.
54352 54352 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
54353 54353
54354 54354 else
54355 54355 # We're on a unix platform. Hooray! :)
54356 54356 path="$MSVC_DLL"
54357 54357 has_space=`$ECHO "$path" | $GREP " "`
54358 54358 if test "x$has_space" != x; then
54359 54359 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54360 54360 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54361 54361 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
54362 54362 fi
54363 54363
54364 54364 # Use eval to expand a potential ~
54365 54365 eval path="$path"
54366 54366 if test ! -f "$path" && test ! -d "$path"; then
54367 54367 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
54368 54368 fi
54369 54369
54370 54370 if test -d "$path"; then
54371 54371 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
54372 54372 else
54373 54373 dir="`$DIRNAME "$path"`"
54374 54374 base="`$BASENAME "$path"`"
54375 54375 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
54376 54376 fi
54377 54377 fi
54378 54378 fi
54379 54379
54380 54380 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54381 54381 $as_echo_n "checking for $DLL_NAME... " >&6; }
54382 54382 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
54383 54383 $as_echo "$MSVC_DLL" >&6; }
54384 54384 else
54385 54385 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
54386 54386 $as_echo "incorrect, ignoring" >&6; }
54387 54387 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
54388 54388 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54389 54389 fi
54390 54390 fi
54391 54391
54392 54392 fi
54393 54393 fi
54394 54394
54395 54395 if test "x$MSVC_DLL" = x; then
54396 54396 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
54397 54397 # (This was the original behaviour; kept since it might turn something up)
54398 54398 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
54399 54399 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
54400 54400 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
54401 54401 | $GREP x64 | $HEAD --lines 1`
54402 54402 else
54403 54403 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
54404 54404 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
54405 54405 if test "x$POSSIBLE_MSVC_DLL" = x; then
54406 54406 # We're grasping at straws now...
54407 54407 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
54408 54408 | $HEAD --lines 1`
54409 54409 fi
54410 54410 fi
54411 54411
54412 54412
54413 54413 DLL_NAME="$DLL_NAME"
54414 54414 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
54415 54415 METHOD="search of VCINSTALLDIR"
54416 54416 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
54417 54417 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
54418 54418 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
54419 54419
54420 54420 # Need to check if the found msvcr is correct architecture
54421 54421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
54422 54422 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
54423 54423 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
54424 54424 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54425 54425 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
54426 54426 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
54427 54427 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54428 54428 CORRECT_MSVCR_ARCH="PE32 executable"
54429 54429 else
54430 54430 CORRECT_MSVCR_ARCH="PE32+ executable"
54431 54431 fi
54432 54432 else
54433 54433 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54434 54434 CORRECT_MSVCR_ARCH=386
54435 54435 else
54436 54436 CORRECT_MSVCR_ARCH=x86-64
54437 54437 fi
54438 54438 fi
54439 54439 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
54440 54440 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
54441 54441 $as_echo "ok" >&6; }
54442 54442 MSVC_DLL="$POSSIBLE_MSVC_DLL"
54443 54443
54444 54444 # Only process if variable expands to non-empty
54445 54445
54446 54446 if test "x$MSVC_DLL" != x; then
54447 54447 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54448 54448
54449 54449 # Input might be given as Windows format, start by converting to
54450 54450 # unix format.
54451 54451 path="$MSVC_DLL"
54452 54452 new_path=`$CYGPATH -u "$path"`
54453 54453
54454 54454 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
54455 54455 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
54456 54456 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
54457 54457 # "foo.exe" is OK but "foo" is an error.
54458 54458 #
54459 54459 # This test is therefore slightly more accurate than "test -f" to check for file precense.
54460 54460 # It is also a way to make sure we got the proper file name for the real test later on.
54461 54461 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
54462 54462 if test "x$test_shortpath" = x; then
54463 54463 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54464 54464 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54465 54465 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
54466 54466 fi
54467 54467
54468 54468 # Call helper function which possibly converts this using DOS-style short mode.
54469 54469 # If so, the updated path is stored in $new_path.
54470 54470
54471 54471 input_path="$new_path"
54472 54472 # Check if we need to convert this using DOS-style short mode. If the path
54473 54473 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54474 54474 # take no chances and rewrite it.
54475 54475 # Note: m4 eats our [], so we need to use [ and ] instead.
54476 54476 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
54477 54477 if test "x$has_forbidden_chars" != x; then
54478 54478 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54479 54479 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
54480 54480 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
54481 54481 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
54482 54482 # Going to short mode and back again did indeed matter. Since short mode is
54483 54483 # case insensitive, let's make it lowercase to improve readability.
54484 54484 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54485 54485 # Now convert it back to Unix-style (cygpath)
54486 54486 input_path=`$CYGPATH -u "$shortmode_path"`
54487 54487 new_path="$input_path"
54488 54488 fi
54489 54489 fi
54490 54490
54491 54491 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
54492 54492 if test "x$test_cygdrive_prefix" = x; then
54493 54493 # As a simple fix, exclude /usr/bin since it's not a real path.
54494 54494 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
54495 54495 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
54496 54496 # a path prefixed by /cygdrive for fixpath to work.
54497 54497 new_path="$CYGWIN_ROOT_PATH$input_path"
54498 54498 fi
54499 54499 fi
54500 54500
54501 54501
54502 54502 if test "x$path" != "x$new_path"; then
54503 54503 MSVC_DLL="$new_path"
54504 54504 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54505 54505 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54506 54506 fi
54507 54507
54508 54508 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54509 54509
54510 54510 path="$MSVC_DLL"
54511 54511 has_colon=`$ECHO $path | $GREP ^.:`
54512 54512 new_path="$path"
54513 54513 if test "x$has_colon" = x; then
54514 54514 # Not in mixed or Windows style, start by that.
54515 54515 new_path=`cmd //c echo $path`
54516 54516 fi
54517 54517
54518 54518
54519 54519 input_path="$new_path"
54520 54520 # Check if we need to convert this using DOS-style short mode. If the path
54521 54521 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54522 54522 # take no chances and rewrite it.
54523 54523 # Note: m4 eats our [], so we need to use [ and ] instead.
54524 54524 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
54525 54525 if test "x$has_forbidden_chars" != x; then
54526 54526 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54527 54527 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54528 54528 fi
54529 54529
54530 54530
54531 54531 windows_path="$new_path"
54532 54532 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54533 54533 unix_path=`$CYGPATH -u "$windows_path"`
54534 54534 new_path="$unix_path"
54535 54535 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54536 54536 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54537 54537 new_path="$unix_path"
54538 54538 fi
54539 54539
54540 54540 if test "x$path" != "x$new_path"; then
54541 54541 MSVC_DLL="$new_path"
54542 54542 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54543 54543 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54544 54544 fi
54545 54545
54546 54546 # Save the first 10 bytes of this path to the storage, so fixpath can work.
54547 54547 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
54548 54548
54549 54549 else
54550 54550 # We're on a unix platform. Hooray! :)
54551 54551 path="$MSVC_DLL"
54552 54552 has_space=`$ECHO "$path" | $GREP " "`
54553 54553 if test "x$has_space" != x; then
54554 54554 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54555 54555 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54556 54556 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
54557 54557 fi
54558 54558
54559 54559 # Use eval to expand a potential ~
54560 54560 eval path="$path"
54561 54561 if test ! -f "$path" && test ! -d "$path"; then
54562 54562 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
54563 54563 fi
54564 54564
54565 54565 if test -d "$path"; then
54566 54566 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
54567 54567 else
54568 54568 dir="`$DIRNAME "$path"`"
54569 54569 base="`$BASENAME "$path"`"
54570 54570 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
54571 54571 fi
54572 54572 fi
54573 54573 fi
54574 54574
54575 54575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54576 54576 $as_echo_n "checking for $DLL_NAME... " >&6; }
54577 54577 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
54578 54578 $as_echo "$MSVC_DLL" >&6; }
54579 54579 else
54580 54580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
54581 54581 $as_echo "incorrect, ignoring" >&6; }
54582 54582 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
54583 54583 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54584 54584 fi
54585 54585 fi
54586 54586
54587 54587 fi
54588 54588 fi
54589 54589
54590 54590 if test "x$MSVC_DLL" = x; then
54591 54591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54592 54592 $as_echo_n "checking for $DLL_NAME... " >&6; }
54593 54593 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
54594 54594 $as_echo "no" >&6; }
54595 54595 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
54596 54596 fi
54597 54597
54598 54598 MSVCR_DLL="$MSVC_DLL"
54599 54599 fi
54600 54600
54601 54601
54602 54602
54603 54603 # Check whether --with-msvcp-dll was given.
54604 54604 if test "${with_msvcp_dll+set}" = set; then :
54605 54605 withval=$with_msvcp_dll;
54606 54606 fi
54607 54607
54608 54608
54609 54609 if test "x$MSVCP_NAME" != "x"; then
54610 54610 if test "x$with_msvcp_dll" != x; then
54611 54611 # If given explicitely by user, do not probe. If not present, fail directly.
54612 54612
54613 54613 DLL_NAME="$MSVCP_NAME"
54614 54614 POSSIBLE_MSVC_DLL="$with_msvcp_dll"
54615 54615 METHOD="--with-msvcp-dll"
54616 54616 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
54617 54617 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
54618 54618 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
54619 54619
54620 54620 # Need to check if the found msvcr is correct architecture
54621 54621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
54622 54622 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
54623 54623 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
54624 54624 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54625 54625 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
54626 54626 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
54627 54627 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54628 54628 CORRECT_MSVCR_ARCH="PE32 executable"
54629 54629 else
54630 54630 CORRECT_MSVCR_ARCH="PE32+ executable"
54631 54631 fi
54632 54632 else
54633 54633 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54634 54634 CORRECT_MSVCR_ARCH=386
54635 54635 else
54636 54636 CORRECT_MSVCR_ARCH=x86-64
54637 54637 fi
54638 54638 fi
54639 54639 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
54640 54640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
54641 54641 $as_echo "ok" >&6; }
54642 54642 MSVC_DLL="$POSSIBLE_MSVC_DLL"
54643 54643
54644 54644 # Only process if variable expands to non-empty
54645 54645
54646 54646 if test "x$MSVC_DLL" != x; then
54647 54647 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54648 54648
54649 54649 # Input might be given as Windows format, start by converting to
54650 54650 # unix format.
54651 54651 path="$MSVC_DLL"
54652 54652 new_path=`$CYGPATH -u "$path"`
54653 54653
54654 54654 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
54655 54655 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
54656 54656 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
54657 54657 # "foo.exe" is OK but "foo" is an error.
54658 54658 #
54659 54659 # This test is therefore slightly more accurate than "test -f" to check for file precense.
54660 54660 # It is also a way to make sure we got the proper file name for the real test later on.
54661 54661 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
54662 54662 if test "x$test_shortpath" = x; then
54663 54663 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54664 54664 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54665 54665 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
54666 54666 fi
54667 54667
54668 54668 # Call helper function which possibly converts this using DOS-style short mode.
54669 54669 # If so, the updated path is stored in $new_path.
54670 54670
54671 54671 input_path="$new_path"
54672 54672 # Check if we need to convert this using DOS-style short mode. If the path
54673 54673 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54674 54674 # take no chances and rewrite it.
54675 54675 # Note: m4 eats our [], so we need to use [ and ] instead.
54676 54676 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
54677 54677 if test "x$has_forbidden_chars" != x; then
54678 54678 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54679 54679 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
54680 54680 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
54681 54681 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
54682 54682 # Going to short mode and back again did indeed matter. Since short mode is
54683 54683 # case insensitive, let's make it lowercase to improve readability.
54684 54684 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54685 54685 # Now convert it back to Unix-style (cygpath)
54686 54686 input_path=`$CYGPATH -u "$shortmode_path"`
54687 54687 new_path="$input_path"
54688 54688 fi
54689 54689 fi
54690 54690
54691 54691 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
54692 54692 if test "x$test_cygdrive_prefix" = x; then
54693 54693 # As a simple fix, exclude /usr/bin since it's not a real path.
54694 54694 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
54695 54695 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
54696 54696 # a path prefixed by /cygdrive for fixpath to work.
54697 54697 new_path="$CYGWIN_ROOT_PATH$input_path"
54698 54698 fi
54699 54699 fi
54700 54700
54701 54701
54702 54702 if test "x$path" != "x$new_path"; then
54703 54703 MSVC_DLL="$new_path"
54704 54704 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54705 54705 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54706 54706 fi
54707 54707
54708 54708 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54709 54709
54710 54710 path="$MSVC_DLL"
54711 54711 has_colon=`$ECHO $path | $GREP ^.:`
54712 54712 new_path="$path"
54713 54713 if test "x$has_colon" = x; then
54714 54714 # Not in mixed or Windows style, start by that.
54715 54715 new_path=`cmd //c echo $path`
54716 54716 fi
54717 54717
54718 54718
54719 54719 input_path="$new_path"
54720 54720 # Check if we need to convert this using DOS-style short mode. If the path
54721 54721 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54722 54722 # take no chances and rewrite it.
54723 54723 # Note: m4 eats our [], so we need to use [ and ] instead.
54724 54724 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
54725 54725 if test "x$has_forbidden_chars" != x; then
54726 54726 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54727 54727 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54728 54728 fi
54729 54729
54730 54730
54731 54731 windows_path="$new_path"
54732 54732 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54733 54733 unix_path=`$CYGPATH -u "$windows_path"`
54734 54734 new_path="$unix_path"
54735 54735 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54736 54736 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54737 54737 new_path="$unix_path"
54738 54738 fi
54739 54739
54740 54740 if test "x$path" != "x$new_path"; then
54741 54741 MSVC_DLL="$new_path"
54742 54742 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54743 54743 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54744 54744 fi
54745 54745
54746 54746 # Save the first 10 bytes of this path to the storage, so fixpath can work.
54747 54747 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
54748 54748
54749 54749 else
54750 54750 # We're on a unix platform. Hooray! :)
54751 54751 path="$MSVC_DLL"
54752 54752 has_space=`$ECHO "$path" | $GREP " "`
54753 54753 if test "x$has_space" != x; then
54754 54754 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54755 54755 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54756 54756 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
54757 54757 fi
54758 54758
54759 54759 # Use eval to expand a potential ~
54760 54760 eval path="$path"
54761 54761 if test ! -f "$path" && test ! -d "$path"; then
54762 54762 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
54763 54763 fi
54764 54764
54765 54765 if test -d "$path"; then
54766 54766 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
54767 54767 else
54768 54768 dir="`$DIRNAME "$path"`"
54769 54769 base="`$BASENAME "$path"`"
54770 54770 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
54771 54771 fi
54772 54772 fi
54773 54773 fi
54774 54774
54775 54775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54776 54776 $as_echo_n "checking for $DLL_NAME... " >&6; }
54777 54777 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
54778 54778 $as_echo "$MSVC_DLL" >&6; }
54779 54779 else
54780 54780 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
54781 54781 $as_echo "incorrect, ignoring" >&6; }
54782 54782 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
54783 54783 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54784 54784 fi
54785 54785 fi
54786 54786
54787 54787 if test "x$MSVC_DLL" = x; then
54788 54788 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5
54789 54789 fi
54790 54790 MSVCP_DLL="$MSVC_DLL"
54791 54791 elif test "x$DEVKIT_MSVCP_DLL" != x; then
54792 54792
54793 54793 DLL_NAME="$MSVCP_NAME"
54794 54794 POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL"
54795 54795 METHOD="devkit"
54796 54796 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
54797 54797 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
54798 54798 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
54799 54799
54800 54800 # Need to check if the found msvcr is correct architecture
54801 54801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
54802 54802 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
54803 54803 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
54804 54804 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54805 54805 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
54806 54806 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
54807 54807 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54808 54808 CORRECT_MSVCR_ARCH="PE32 executable"
54809 54809 else
54810 54810 CORRECT_MSVCR_ARCH="PE32+ executable"
54811 54811 fi
54812 54812 else
54813 54813 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
54814 54814 CORRECT_MSVCR_ARCH=386
54815 54815 else
54816 54816 CORRECT_MSVCR_ARCH=x86-64
54817 54817 fi
54818 54818 fi
54819 54819 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
54820 54820 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
54821 54821 $as_echo "ok" >&6; }
54822 54822 MSVC_DLL="$POSSIBLE_MSVC_DLL"
54823 54823
54824 54824 # Only process if variable expands to non-empty
54825 54825
54826 54826 if test "x$MSVC_DLL" != x; then
54827 54827 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54828 54828
54829 54829 # Input might be given as Windows format, start by converting to
54830 54830 # unix format.
54831 54831 path="$MSVC_DLL"
54832 54832 new_path=`$CYGPATH -u "$path"`
54833 54833
54834 54834 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
54835 54835 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
54836 54836 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
54837 54837 # "foo.exe" is OK but "foo" is an error.
54838 54838 #
54839 54839 # This test is therefore slightly more accurate than "test -f" to check for file precense.
54840 54840 # It is also a way to make sure we got the proper file name for the real test later on.
54841 54841 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
54842 54842 if test "x$test_shortpath" = x; then
54843 54843 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54844 54844 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54845 54845 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
54846 54846 fi
54847 54847
54848 54848 # Call helper function which possibly converts this using DOS-style short mode.
54849 54849 # If so, the updated path is stored in $new_path.
54850 54850
54851 54851 input_path="$new_path"
54852 54852 # Check if we need to convert this using DOS-style short mode. If the path
54853 54853 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54854 54854 # take no chances and rewrite it.
54855 54855 # Note: m4 eats our [], so we need to use [ and ] instead.
54856 54856 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
54857 54857 if test "x$has_forbidden_chars" != x; then
54858 54858 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54859 54859 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
54860 54860 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
54861 54861 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
54862 54862 # Going to short mode and back again did indeed matter. Since short mode is
54863 54863 # case insensitive, let's make it lowercase to improve readability.
54864 54864 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54865 54865 # Now convert it back to Unix-style (cygpath)
54866 54866 input_path=`$CYGPATH -u "$shortmode_path"`
54867 54867 new_path="$input_path"
54868 54868 fi
54869 54869 fi
54870 54870
54871 54871 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
54872 54872 if test "x$test_cygdrive_prefix" = x; then
54873 54873 # As a simple fix, exclude /usr/bin since it's not a real path.
54874 54874 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
54875 54875 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
54876 54876 # a path prefixed by /cygdrive for fixpath to work.
54877 54877 new_path="$CYGWIN_ROOT_PATH$input_path"
54878 54878 fi
54879 54879 fi
54880 54880
54881 54881
54882 54882 if test "x$path" != "x$new_path"; then
54883 54883 MSVC_DLL="$new_path"
54884 54884 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54885 54885 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54886 54886 fi
54887 54887
54888 54888 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54889 54889
54890 54890 path="$MSVC_DLL"
54891 54891 has_colon=`$ECHO $path | $GREP ^.:`
54892 54892 new_path="$path"
54893 54893 if test "x$has_colon" = x; then
54894 54894 # Not in mixed or Windows style, start by that.
54895 54895 new_path=`cmd //c echo $path`
54896 54896 fi
54897 54897
54898 54898
54899 54899 input_path="$new_path"
54900 54900 # Check if we need to convert this using DOS-style short mode. If the path
54901 54901 # contains just simple characters, use it. Otherwise (spaces, weird characters),
54902 54902 # take no chances and rewrite it.
54903 54903 # Note: m4 eats our [], so we need to use [ and ] instead.
54904 54904 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
54905 54905 if test "x$has_forbidden_chars" != x; then
54906 54906 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
54907 54907 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
54908 54908 fi
54909 54909
54910 54910
54911 54911 windows_path="$new_path"
54912 54912 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54913 54913 unix_path=`$CYGPATH -u "$windows_path"`
54914 54914 new_path="$unix_path"
54915 54915 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54916 54916 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54917 54917 new_path="$unix_path"
54918 54918 fi
54919 54919
54920 54920 if test "x$path" != "x$new_path"; then
54921 54921 MSVC_DLL="$new_path"
54922 54922 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
54923 54923 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
54924 54924 fi
54925 54925
54926 54926 # Save the first 10 bytes of this path to the storage, so fixpath can work.
54927 54927 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
54928 54928
54929 54929 else
54930 54930 # We're on a unix platform. Hooray! :)
54931 54931 path="$MSVC_DLL"
54932 54932 has_space=`$ECHO "$path" | $GREP " "`
54933 54933 if test "x$has_space" != x; then
54934 54934 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
54935 54935 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
54936 54936 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
54937 54937 fi
54938 54938
54939 54939 # Use eval to expand a potential ~
54940 54940 eval path="$path"
54941 54941 if test ! -f "$path" && test ! -d "$path"; then
54942 54942 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
54943 54943 fi
54944 54944
54945 54945 if test -d "$path"; then
54946 54946 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
54947 54947 else
54948 54948 dir="`$DIRNAME "$path"`"
54949 54949 base="`$BASENAME "$path"`"
54950 54950 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
54951 54951 fi
54952 54952 fi
54953 54953 fi
54954 54954
54955 54955 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
54956 54956 $as_echo_n "checking for $DLL_NAME... " >&6; }
54957 54957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
54958 54958 $as_echo "$MSVC_DLL" >&6; }
54959 54959 else
54960 54960 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
54961 54961 $as_echo "incorrect, ignoring" >&6; }
54962 54962 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
54963 54963 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
54964 54964 fi
54965 54965 fi
54966 54966
54967 54967 if test "x$MSVC_DLL" = x; then
54968 54968 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by devkit" "$LINENO" 5
54969 54969 fi
54970 54970 MSVCP_DLL="$MSVC_DLL"
54971 54971 else
54972 54972
54973 54973 DLL_NAME="${MSVCP_NAME}"
54974 54974 MSVC_DLL=
54975 54975
54976 54976 if test "x$MSVC_DLL" = x; then
54977 54977 # Probe: Using well-known location from Visual Studio 10.0
54978 54978 if test "x$VCINSTALLDIR" != x; then
54979 54979 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
54980 54980
54981 54981 windows_path="$CYGWIN_VC_INSTALL_DIR"
54982 54982 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
54983 54983 unix_path=`$CYGPATH -u "$windows_path"`
54984 54984 CYGWIN_VC_INSTALL_DIR="$unix_path"
54985 54985 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
54986 54986 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
54987 54987 CYGWIN_VC_INSTALL_DIR="$unix_path"
54988 54988 fi
54989 54989
54990 54990 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
54991 54991 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
54992 54992 else
54993 54993 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
54994 54994 fi
54995 54995 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
54996 54996
54997 54997 DLL_NAME="$DLL_NAME"
54998 54998 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
54999 54999 METHOD="well-known location in VCINSTALLDIR"
55000 55000 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
55001 55001 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
55002 55002 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
55003 55003
55004 55004 # Need to check if the found msvcr is correct architecture
55005 55005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
55006 55006 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
55007 55007 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
55008 55008 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55009 55009 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
55010 55010 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
55011 55011 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55012 55012 CORRECT_MSVCR_ARCH="PE32 executable"
55013 55013 else
55014 55014 CORRECT_MSVCR_ARCH="PE32+ executable"
55015 55015 fi
55016 55016 else
55017 55017 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55018 55018 CORRECT_MSVCR_ARCH=386
55019 55019 else
55020 55020 CORRECT_MSVCR_ARCH=x86-64
55021 55021 fi
55022 55022 fi
55023 55023 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
55024 55024 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
55025 55025 $as_echo "ok" >&6; }
55026 55026 MSVC_DLL="$POSSIBLE_MSVC_DLL"
55027 55027
55028 55028 # Only process if variable expands to non-empty
55029 55029
55030 55030 if test "x$MSVC_DLL" != x; then
55031 55031 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55032 55032
55033 55033 # Input might be given as Windows format, start by converting to
55034 55034 # unix format.
55035 55035 path="$MSVC_DLL"
55036 55036 new_path=`$CYGPATH -u "$path"`
55037 55037
55038 55038 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
55039 55039 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
55040 55040 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
55041 55041 # "foo.exe" is OK but "foo" is an error.
55042 55042 #
55043 55043 # This test is therefore slightly more accurate than "test -f" to check for file precense.
55044 55044 # It is also a way to make sure we got the proper file name for the real test later on.
55045 55045 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
55046 55046 if test "x$test_shortpath" = x; then
55047 55047 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55048 55048 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55049 55049 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
55050 55050 fi
55051 55051
55052 55052 # Call helper function which possibly converts this using DOS-style short mode.
55053 55053 # If so, the updated path is stored in $new_path.
55054 55054
55055 55055 input_path="$new_path"
55056 55056 # Check if we need to convert this using DOS-style short mode. If the path
55057 55057 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55058 55058 # take no chances and rewrite it.
55059 55059 # Note: m4 eats our [], so we need to use [ and ] instead.
55060 55060 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
55061 55061 if test "x$has_forbidden_chars" != x; then
55062 55062 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55063 55063 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
55064 55064 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
55065 55065 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
55066 55066 # Going to short mode and back again did indeed matter. Since short mode is
55067 55067 # case insensitive, let's make it lowercase to improve readability.
55068 55068 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55069 55069 # Now convert it back to Unix-style (cygpath)
55070 55070 input_path=`$CYGPATH -u "$shortmode_path"`
55071 55071 new_path="$input_path"
55072 55072 fi
55073 55073 fi
55074 55074
55075 55075 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
55076 55076 if test "x$test_cygdrive_prefix" = x; then
55077 55077 # As a simple fix, exclude /usr/bin since it's not a real path.
55078 55078 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
55079 55079 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
55080 55080 # a path prefixed by /cygdrive for fixpath to work.
55081 55081 new_path="$CYGWIN_ROOT_PATH$input_path"
55082 55082 fi
55083 55083 fi
55084 55084
55085 55085
55086 55086 if test "x$path" != "x$new_path"; then
55087 55087 MSVC_DLL="$new_path"
55088 55088 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55089 55089 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55090 55090 fi
55091 55091
55092 55092 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55093 55093
55094 55094 path="$MSVC_DLL"
55095 55095 has_colon=`$ECHO $path | $GREP ^.:`
55096 55096 new_path="$path"
55097 55097 if test "x$has_colon" = x; then
55098 55098 # Not in mixed or Windows style, start by that.
55099 55099 new_path=`cmd //c echo $path`
55100 55100 fi
55101 55101
55102 55102
55103 55103 input_path="$new_path"
55104 55104 # Check if we need to convert this using DOS-style short mode. If the path
55105 55105 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55106 55106 # take no chances and rewrite it.
55107 55107 # Note: m4 eats our [], so we need to use [ and ] instead.
55108 55108 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
55109 55109 if test "x$has_forbidden_chars" != x; then
55110 55110 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55111 55111 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55112 55112 fi
55113 55113
55114 55114
55115 55115 windows_path="$new_path"
55116 55116 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55117 55117 unix_path=`$CYGPATH -u "$windows_path"`
55118 55118 new_path="$unix_path"
55119 55119 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55120 55120 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55121 55121 new_path="$unix_path"
55122 55122 fi
55123 55123
55124 55124 if test "x$path" != "x$new_path"; then
55125 55125 MSVC_DLL="$new_path"
55126 55126 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55127 55127 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55128 55128 fi
55129 55129
55130 55130 # Save the first 10 bytes of this path to the storage, so fixpath can work.
55131 55131 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
55132 55132
55133 55133 else
55134 55134 # We're on a unix platform. Hooray! :)
55135 55135 path="$MSVC_DLL"
55136 55136 has_space=`$ECHO "$path" | $GREP " "`
55137 55137 if test "x$has_space" != x; then
55138 55138 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55139 55139 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55140 55140 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
55141 55141 fi
55142 55142
55143 55143 # Use eval to expand a potential ~
55144 55144 eval path="$path"
55145 55145 if test ! -f "$path" && test ! -d "$path"; then
55146 55146 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
55147 55147 fi
55148 55148
55149 55149 if test -d "$path"; then
55150 55150 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
55151 55151 else
55152 55152 dir="`$DIRNAME "$path"`"
55153 55153 base="`$BASENAME "$path"`"
55154 55154 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
55155 55155 fi
55156 55156 fi
55157 55157 fi
55158 55158
55159 55159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55160 55160 $as_echo_n "checking for $DLL_NAME... " >&6; }
55161 55161 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
55162 55162 $as_echo "$MSVC_DLL" >&6; }
55163 55163 else
55164 55164 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
55165 55165 $as_echo "incorrect, ignoring" >&6; }
55166 55166 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
55167 55167 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
55168 55168 fi
55169 55169 fi
55170 55170
55171 55171 fi
55172 55172 fi
55173 55173
55174 55174 if test "x$MSVC_DLL" = x; then
55175 55175 # Probe: Check in the Boot JDK directory.
55176 55176 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
55177 55177
55178 55178 DLL_NAME="$DLL_NAME"
55179 55179 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
55180 55180 METHOD="well-known location in Boot JDK"
55181 55181 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
55182 55182 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
55183 55183 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
55184 55184
55185 55185 # Need to check if the found msvcr is correct architecture
55186 55186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
55187 55187 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
55188 55188 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
55189 55189 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55190 55190 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
55191 55191 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
55192 55192 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55193 55193 CORRECT_MSVCR_ARCH="PE32 executable"
55194 55194 else
55195 55195 CORRECT_MSVCR_ARCH="PE32+ executable"
55196 55196 fi
55197 55197 else
55198 55198 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55199 55199 CORRECT_MSVCR_ARCH=386
55200 55200 else
55201 55201 CORRECT_MSVCR_ARCH=x86-64
55202 55202 fi
55203 55203 fi
55204 55204 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
55205 55205 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
55206 55206 $as_echo "ok" >&6; }
55207 55207 MSVC_DLL="$POSSIBLE_MSVC_DLL"
55208 55208
55209 55209 # Only process if variable expands to non-empty
55210 55210
55211 55211 if test "x$MSVC_DLL" != x; then
55212 55212 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55213 55213
55214 55214 # Input might be given as Windows format, start by converting to
55215 55215 # unix format.
55216 55216 path="$MSVC_DLL"
55217 55217 new_path=`$CYGPATH -u "$path"`
55218 55218
55219 55219 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
55220 55220 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
55221 55221 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
55222 55222 # "foo.exe" is OK but "foo" is an error.
55223 55223 #
55224 55224 # This test is therefore slightly more accurate than "test -f" to check for file precense.
55225 55225 # It is also a way to make sure we got the proper file name for the real test later on.
55226 55226 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
55227 55227 if test "x$test_shortpath" = x; then
55228 55228 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55229 55229 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55230 55230 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
55231 55231 fi
55232 55232
55233 55233 # Call helper function which possibly converts this using DOS-style short mode.
55234 55234 # If so, the updated path is stored in $new_path.
55235 55235
55236 55236 input_path="$new_path"
55237 55237 # Check if we need to convert this using DOS-style short mode. If the path
55238 55238 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55239 55239 # take no chances and rewrite it.
55240 55240 # Note: m4 eats our [], so we need to use [ and ] instead.
55241 55241 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
55242 55242 if test "x$has_forbidden_chars" != x; then
55243 55243 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55244 55244 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
55245 55245 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
55246 55246 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
55247 55247 # Going to short mode and back again did indeed matter. Since short mode is
55248 55248 # case insensitive, let's make it lowercase to improve readability.
55249 55249 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55250 55250 # Now convert it back to Unix-style (cygpath)
55251 55251 input_path=`$CYGPATH -u "$shortmode_path"`
55252 55252 new_path="$input_path"
55253 55253 fi
55254 55254 fi
55255 55255
55256 55256 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
55257 55257 if test "x$test_cygdrive_prefix" = x; then
55258 55258 # As a simple fix, exclude /usr/bin since it's not a real path.
55259 55259 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
55260 55260 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
55261 55261 # a path prefixed by /cygdrive for fixpath to work.
55262 55262 new_path="$CYGWIN_ROOT_PATH$input_path"
55263 55263 fi
55264 55264 fi
55265 55265
55266 55266
55267 55267 if test "x$path" != "x$new_path"; then
55268 55268 MSVC_DLL="$new_path"
55269 55269 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55270 55270 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55271 55271 fi
55272 55272
55273 55273 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55274 55274
55275 55275 path="$MSVC_DLL"
55276 55276 has_colon=`$ECHO $path | $GREP ^.:`
55277 55277 new_path="$path"
55278 55278 if test "x$has_colon" = x; then
55279 55279 # Not in mixed or Windows style, start by that.
55280 55280 new_path=`cmd //c echo $path`
55281 55281 fi
55282 55282
55283 55283
55284 55284 input_path="$new_path"
55285 55285 # Check if we need to convert this using DOS-style short mode. If the path
55286 55286 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55287 55287 # take no chances and rewrite it.
55288 55288 # Note: m4 eats our [], so we need to use [ and ] instead.
55289 55289 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
55290 55290 if test "x$has_forbidden_chars" != x; then
55291 55291 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55292 55292 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55293 55293 fi
55294 55294
55295 55295
55296 55296 windows_path="$new_path"
55297 55297 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55298 55298 unix_path=`$CYGPATH -u "$windows_path"`
55299 55299 new_path="$unix_path"
55300 55300 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55301 55301 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55302 55302 new_path="$unix_path"
55303 55303 fi
55304 55304
55305 55305 if test "x$path" != "x$new_path"; then
55306 55306 MSVC_DLL="$new_path"
55307 55307 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55308 55308 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55309 55309 fi
55310 55310
55311 55311 # Save the first 10 bytes of this path to the storage, so fixpath can work.
55312 55312 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
55313 55313
55314 55314 else
55315 55315 # We're on a unix platform. Hooray! :)
55316 55316 path="$MSVC_DLL"
55317 55317 has_space=`$ECHO "$path" | $GREP " "`
55318 55318 if test "x$has_space" != x; then
55319 55319 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55320 55320 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55321 55321 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
55322 55322 fi
55323 55323
55324 55324 # Use eval to expand a potential ~
55325 55325 eval path="$path"
55326 55326 if test ! -f "$path" && test ! -d "$path"; then
55327 55327 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
55328 55328 fi
55329 55329
55330 55330 if test -d "$path"; then
55331 55331 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
55332 55332 else
55333 55333 dir="`$DIRNAME "$path"`"
55334 55334 base="`$BASENAME "$path"`"
55335 55335 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
55336 55336 fi
55337 55337 fi
55338 55338 fi
55339 55339
55340 55340 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55341 55341 $as_echo_n "checking for $DLL_NAME... " >&6; }
55342 55342 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
55343 55343 $as_echo "$MSVC_DLL" >&6; }
55344 55344 else
55345 55345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
55346 55346 $as_echo "incorrect, ignoring" >&6; }
55347 55347 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
55348 55348 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
55349 55349 fi
55350 55350 fi
55351 55351
55352 55352 fi
55353 55353
55354 55354 if test "x$MSVC_DLL" = x; then
55355 55355 # Probe: Look in the Windows system32 directory
55356 55356 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
55357 55357
55358 55358 windows_path="$CYGWIN_SYSTEMROOT"
55359 55359 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55360 55360 unix_path=`$CYGPATH -u "$windows_path"`
55361 55361 CYGWIN_SYSTEMROOT="$unix_path"
55362 55362 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55363 55363 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55364 55364 CYGWIN_SYSTEMROOT="$unix_path"
55365 55365 fi
55366 55366
55367 55367 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
55368 55368
55369 55369 DLL_NAME="$DLL_NAME"
55370 55370 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
55371 55371 METHOD="well-known location in SYSTEMROOT"
55372 55372 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
55373 55373 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
55374 55374 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
55375 55375
55376 55376 # Need to check if the found msvcr is correct architecture
55377 55377 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
55378 55378 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
55379 55379 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
55380 55380 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55381 55381 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
55382 55382 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
55383 55383 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55384 55384 CORRECT_MSVCR_ARCH="PE32 executable"
55385 55385 else
55386 55386 CORRECT_MSVCR_ARCH="PE32+ executable"
55387 55387 fi
55388 55388 else
55389 55389 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55390 55390 CORRECT_MSVCR_ARCH=386
55391 55391 else
55392 55392 CORRECT_MSVCR_ARCH=x86-64
55393 55393 fi
55394 55394 fi
55395 55395 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
55396 55396 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
55397 55397 $as_echo "ok" >&6; }
55398 55398 MSVC_DLL="$POSSIBLE_MSVC_DLL"
55399 55399
55400 55400 # Only process if variable expands to non-empty
55401 55401
55402 55402 if test "x$MSVC_DLL" != x; then
55403 55403 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55404 55404
55405 55405 # Input might be given as Windows format, start by converting to
55406 55406 # unix format.
55407 55407 path="$MSVC_DLL"
55408 55408 new_path=`$CYGPATH -u "$path"`
55409 55409
55410 55410 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
55411 55411 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
55412 55412 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
55413 55413 # "foo.exe" is OK but "foo" is an error.
55414 55414 #
55415 55415 # This test is therefore slightly more accurate than "test -f" to check for file precense.
55416 55416 # It is also a way to make sure we got the proper file name for the real test later on.
55417 55417 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
55418 55418 if test "x$test_shortpath" = x; then
55419 55419 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55420 55420 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55421 55421 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
55422 55422 fi
55423 55423
55424 55424 # Call helper function which possibly converts this using DOS-style short mode.
55425 55425 # If so, the updated path is stored in $new_path.
55426 55426
55427 55427 input_path="$new_path"
55428 55428 # Check if we need to convert this using DOS-style short mode. If the path
55429 55429 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55430 55430 # take no chances and rewrite it.
55431 55431 # Note: m4 eats our [], so we need to use [ and ] instead.
55432 55432 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
55433 55433 if test "x$has_forbidden_chars" != x; then
55434 55434 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55435 55435 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
55436 55436 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
55437 55437 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
55438 55438 # Going to short mode and back again did indeed matter. Since short mode is
55439 55439 # case insensitive, let's make it lowercase to improve readability.
55440 55440 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55441 55441 # Now convert it back to Unix-style (cygpath)
55442 55442 input_path=`$CYGPATH -u "$shortmode_path"`
55443 55443 new_path="$input_path"
55444 55444 fi
55445 55445 fi
55446 55446
55447 55447 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
55448 55448 if test "x$test_cygdrive_prefix" = x; then
55449 55449 # As a simple fix, exclude /usr/bin since it's not a real path.
55450 55450 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
55451 55451 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
55452 55452 # a path prefixed by /cygdrive for fixpath to work.
55453 55453 new_path="$CYGWIN_ROOT_PATH$input_path"
55454 55454 fi
55455 55455 fi
55456 55456
55457 55457
55458 55458 if test "x$path" != "x$new_path"; then
55459 55459 MSVC_DLL="$new_path"
55460 55460 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55461 55461 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55462 55462 fi
55463 55463
55464 55464 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55465 55465
55466 55466 path="$MSVC_DLL"
55467 55467 has_colon=`$ECHO $path | $GREP ^.:`
55468 55468 new_path="$path"
55469 55469 if test "x$has_colon" = x; then
55470 55470 # Not in mixed or Windows style, start by that.
55471 55471 new_path=`cmd //c echo $path`
55472 55472 fi
55473 55473
55474 55474
55475 55475 input_path="$new_path"
55476 55476 # Check if we need to convert this using DOS-style short mode. If the path
55477 55477 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55478 55478 # take no chances and rewrite it.
55479 55479 # Note: m4 eats our [], so we need to use [ and ] instead.
55480 55480 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
55481 55481 if test "x$has_forbidden_chars" != x; then
55482 55482 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55483 55483 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55484 55484 fi
55485 55485
55486 55486
55487 55487 windows_path="$new_path"
55488 55488 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55489 55489 unix_path=`$CYGPATH -u "$windows_path"`
55490 55490 new_path="$unix_path"
55491 55491 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55492 55492 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55493 55493 new_path="$unix_path"
55494 55494 fi
55495 55495
55496 55496 if test "x$path" != "x$new_path"; then
55497 55497 MSVC_DLL="$new_path"
55498 55498 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55499 55499 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55500 55500 fi
55501 55501
55502 55502 # Save the first 10 bytes of this path to the storage, so fixpath can work.
55503 55503 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
55504 55504
55505 55505 else
55506 55506 # We're on a unix platform. Hooray! :)
55507 55507 path="$MSVC_DLL"
55508 55508 has_space=`$ECHO "$path" | $GREP " "`
55509 55509 if test "x$has_space" != x; then
55510 55510 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55511 55511 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55512 55512 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
55513 55513 fi
55514 55514
55515 55515 # Use eval to expand a potential ~
55516 55516 eval path="$path"
55517 55517 if test ! -f "$path" && test ! -d "$path"; then
55518 55518 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
55519 55519 fi
55520 55520
55521 55521 if test -d "$path"; then
55522 55522 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
55523 55523 else
55524 55524 dir="`$DIRNAME "$path"`"
55525 55525 base="`$BASENAME "$path"`"
55526 55526 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
55527 55527 fi
55528 55528 fi
55529 55529 fi
55530 55530
55531 55531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55532 55532 $as_echo_n "checking for $DLL_NAME... " >&6; }
55533 55533 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
55534 55534 $as_echo "$MSVC_DLL" >&6; }
55535 55535 else
55536 55536 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
55537 55537 $as_echo "incorrect, ignoring" >&6; }
55538 55538 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
55539 55539 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
55540 55540 fi
55541 55541 fi
55542 55542
55543 55543 fi
55544 55544
55545 55545 if test "x$MSVC_DLL" = x; then
55546 55546 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
55547 55547 if test "x$VS100COMNTOOLS" != x; then
55548 55548 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
55549 55549
55550 55550 windows_path="$CYGWIN_VS_TOOLS_DIR"
55551 55551 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55552 55552 unix_path=`$CYGPATH -u "$windows_path"`
55553 55553 CYGWIN_VS_TOOLS_DIR="$unix_path"
55554 55554 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55555 55555 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55556 55556 CYGWIN_VS_TOOLS_DIR="$unix_path"
55557 55557 fi
55558 55558
55559 55559 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
55560 55560 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
55561 55561 | $GREP -i /x64/ | $HEAD --lines 1`
55562 55562 else
55563 55563 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
55564 55564 | $GREP -i /x86/ | $HEAD --lines 1`
55565 55565 fi
55566 55566
55567 55567 DLL_NAME="$DLL_NAME"
55568 55568 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
55569 55569 METHOD="search of VS100COMNTOOLS"
55570 55570 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
55571 55571 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
55572 55572 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
55573 55573
55574 55574 # Need to check if the found msvcr is correct architecture
55575 55575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
55576 55576 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
55577 55577 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
55578 55578 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55579 55579 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
55580 55580 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
55581 55581 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55582 55582 CORRECT_MSVCR_ARCH="PE32 executable"
55583 55583 else
55584 55584 CORRECT_MSVCR_ARCH="PE32+ executable"
55585 55585 fi
55586 55586 else
55587 55587 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55588 55588 CORRECT_MSVCR_ARCH=386
55589 55589 else
55590 55590 CORRECT_MSVCR_ARCH=x86-64
55591 55591 fi
55592 55592 fi
55593 55593 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
55594 55594 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
55595 55595 $as_echo "ok" >&6; }
55596 55596 MSVC_DLL="$POSSIBLE_MSVC_DLL"
55597 55597
55598 55598 # Only process if variable expands to non-empty
55599 55599
55600 55600 if test "x$MSVC_DLL" != x; then
55601 55601 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55602 55602
55603 55603 # Input might be given as Windows format, start by converting to
55604 55604 # unix format.
55605 55605 path="$MSVC_DLL"
55606 55606 new_path=`$CYGPATH -u "$path"`
55607 55607
55608 55608 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
55609 55609 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
55610 55610 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
55611 55611 # "foo.exe" is OK but "foo" is an error.
55612 55612 #
55613 55613 # This test is therefore slightly more accurate than "test -f" to check for file precense.
55614 55614 # It is also a way to make sure we got the proper file name for the real test later on.
55615 55615 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
55616 55616 if test "x$test_shortpath" = x; then
55617 55617 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55618 55618 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55619 55619 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
55620 55620 fi
55621 55621
55622 55622 # Call helper function which possibly converts this using DOS-style short mode.
55623 55623 # If so, the updated path is stored in $new_path.
55624 55624
55625 55625 input_path="$new_path"
55626 55626 # Check if we need to convert this using DOS-style short mode. If the path
55627 55627 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55628 55628 # take no chances and rewrite it.
55629 55629 # Note: m4 eats our [], so we need to use [ and ] instead.
55630 55630 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
55631 55631 if test "x$has_forbidden_chars" != x; then
55632 55632 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55633 55633 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
55634 55634 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
55635 55635 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
55636 55636 # Going to short mode and back again did indeed matter. Since short mode is
55637 55637 # case insensitive, let's make it lowercase to improve readability.
55638 55638 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55639 55639 # Now convert it back to Unix-style (cygpath)
55640 55640 input_path=`$CYGPATH -u "$shortmode_path"`
55641 55641 new_path="$input_path"
55642 55642 fi
55643 55643 fi
55644 55644
55645 55645 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
55646 55646 if test "x$test_cygdrive_prefix" = x; then
55647 55647 # As a simple fix, exclude /usr/bin since it's not a real path.
55648 55648 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
55649 55649 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
55650 55650 # a path prefixed by /cygdrive for fixpath to work.
55651 55651 new_path="$CYGWIN_ROOT_PATH$input_path"
55652 55652 fi
55653 55653 fi
55654 55654
55655 55655
55656 55656 if test "x$path" != "x$new_path"; then
55657 55657 MSVC_DLL="$new_path"
55658 55658 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55659 55659 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55660 55660 fi
55661 55661
55662 55662 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55663 55663
55664 55664 path="$MSVC_DLL"
55665 55665 has_colon=`$ECHO $path | $GREP ^.:`
55666 55666 new_path="$path"
55667 55667 if test "x$has_colon" = x; then
55668 55668 # Not in mixed or Windows style, start by that.
55669 55669 new_path=`cmd //c echo $path`
55670 55670 fi
55671 55671
55672 55672
55673 55673 input_path="$new_path"
55674 55674 # Check if we need to convert this using DOS-style short mode. If the path
55675 55675 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55676 55676 # take no chances and rewrite it.
55677 55677 # Note: m4 eats our [], so we need to use [ and ] instead.
55678 55678 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
55679 55679 if test "x$has_forbidden_chars" != x; then
55680 55680 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55681 55681 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55682 55682 fi
55683 55683
55684 55684
55685 55685 windows_path="$new_path"
55686 55686 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55687 55687 unix_path=`$CYGPATH -u "$windows_path"`
55688 55688 new_path="$unix_path"
55689 55689 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55690 55690 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55691 55691 new_path="$unix_path"
55692 55692 fi
55693 55693
55694 55694 if test "x$path" != "x$new_path"; then
55695 55695 MSVC_DLL="$new_path"
55696 55696 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55697 55697 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55698 55698 fi
55699 55699
55700 55700 # Save the first 10 bytes of this path to the storage, so fixpath can work.
55701 55701 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
55702 55702
55703 55703 else
55704 55704 # We're on a unix platform. Hooray! :)
55705 55705 path="$MSVC_DLL"
55706 55706 has_space=`$ECHO "$path" | $GREP " "`
55707 55707 if test "x$has_space" != x; then
55708 55708 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55709 55709 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55710 55710 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
55711 55711 fi
55712 55712
55713 55713 # Use eval to expand a potential ~
55714 55714 eval path="$path"
55715 55715 if test ! -f "$path" && test ! -d "$path"; then
55716 55716 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
55717 55717 fi
55718 55718
55719 55719 if test -d "$path"; then
55720 55720 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
55721 55721 else
55722 55722 dir="`$DIRNAME "$path"`"
55723 55723 base="`$BASENAME "$path"`"
55724 55724 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
55725 55725 fi
55726 55726 fi
55727 55727 fi
55728 55728
55729 55729 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55730 55730 $as_echo_n "checking for $DLL_NAME... " >&6; }
55731 55731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
55732 55732 $as_echo "$MSVC_DLL" >&6; }
55733 55733 else
55734 55734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
55735 55735 $as_echo "incorrect, ignoring" >&6; }
55736 55736 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
55737 55737 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
55738 55738 fi
55739 55739 fi
55740 55740
55741 55741 fi
55742 55742 fi
55743 55743
55744 55744 if test "x$MSVC_DLL" = x; then
55745 55745 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
55746 55746 # (This was the original behaviour; kept since it might turn something up)
55747 55747 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
55748 55748 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
55749 55749 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
55750 55750 | $GREP x64 | $HEAD --lines 1`
55751 55751 else
55752 55752 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
55753 55753 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
55754 55754 if test "x$POSSIBLE_MSVC_DLL" = x; then
55755 55755 # We're grasping at straws now...
55756 55756 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
55757 55757 | $HEAD --lines 1`
55758 55758 fi
55759 55759 fi
55760 55760
55761 55761
55762 55762 DLL_NAME="$DLL_NAME"
55763 55763 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
55764 55764 METHOD="search of VCINSTALLDIR"
55765 55765 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
55766 55766 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
55767 55767 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
55768 55768
55769 55769 # Need to check if the found msvcr is correct architecture
55770 55770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
55771 55771 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
55772 55772 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
55773 55773 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55774 55774 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
55775 55775 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
55776 55776 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55777 55777 CORRECT_MSVCR_ARCH="PE32 executable"
55778 55778 else
55779 55779 CORRECT_MSVCR_ARCH="PE32+ executable"
55780 55780 fi
55781 55781 else
55782 55782 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
55783 55783 CORRECT_MSVCR_ARCH=386
55784 55784 else
55785 55785 CORRECT_MSVCR_ARCH=x86-64
55786 55786 fi
55787 55787 fi
55788 55788 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
55789 55789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
55790 55790 $as_echo "ok" >&6; }
55791 55791 MSVC_DLL="$POSSIBLE_MSVC_DLL"
55792 55792
55793 55793 # Only process if variable expands to non-empty
55794 55794
55795 55795 if test "x$MSVC_DLL" != x; then
55796 55796 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55797 55797
55798 55798 # Input might be given as Windows format, start by converting to
55799 55799 # unix format.
55800 55800 path="$MSVC_DLL"
55801 55801 new_path=`$CYGPATH -u "$path"`
55802 55802
55803 55803 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
55804 55804 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
55805 55805 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
55806 55806 # "foo.exe" is OK but "foo" is an error.
55807 55807 #
55808 55808 # This test is therefore slightly more accurate than "test -f" to check for file precense.
55809 55809 # It is also a way to make sure we got the proper file name for the real test later on.
55810 55810 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
55811 55811 if test "x$test_shortpath" = x; then
55812 55812 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55813 55813 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55814 55814 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
55815 55815 fi
55816 55816
55817 55817 # Call helper function which possibly converts this using DOS-style short mode.
55818 55818 # If so, the updated path is stored in $new_path.
55819 55819
55820 55820 input_path="$new_path"
55821 55821 # Check if we need to convert this using DOS-style short mode. If the path
55822 55822 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55823 55823 # take no chances and rewrite it.
55824 55824 # Note: m4 eats our [], so we need to use [ and ] instead.
55825 55825 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
55826 55826 if test "x$has_forbidden_chars" != x; then
55827 55827 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55828 55828 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
55829 55829 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
55830 55830 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
55831 55831 # Going to short mode and back again did indeed matter. Since short mode is
55832 55832 # case insensitive, let's make it lowercase to improve readability.
55833 55833 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55834 55834 # Now convert it back to Unix-style (cygpath)
55835 55835 input_path=`$CYGPATH -u "$shortmode_path"`
55836 55836 new_path="$input_path"
55837 55837 fi
55838 55838 fi
55839 55839
55840 55840 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
55841 55841 if test "x$test_cygdrive_prefix" = x; then
55842 55842 # As a simple fix, exclude /usr/bin since it's not a real path.
55843 55843 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
55844 55844 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
55845 55845 # a path prefixed by /cygdrive for fixpath to work.
55846 55846 new_path="$CYGWIN_ROOT_PATH$input_path"
55847 55847 fi
55848 55848 fi
55849 55849
55850 55850
55851 55851 if test "x$path" != "x$new_path"; then
55852 55852 MSVC_DLL="$new_path"
55853 55853 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55854 55854 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55855 55855 fi
55856 55856
55857 55857 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55858 55858
55859 55859 path="$MSVC_DLL"
55860 55860 has_colon=`$ECHO $path | $GREP ^.:`
55861 55861 new_path="$path"
55862 55862 if test "x$has_colon" = x; then
55863 55863 # Not in mixed or Windows style, start by that.
55864 55864 new_path=`cmd //c echo $path`
55865 55865 fi
55866 55866
55867 55867
55868 55868 input_path="$new_path"
55869 55869 # Check if we need to convert this using DOS-style short mode. If the path
55870 55870 # contains just simple characters, use it. Otherwise (spaces, weird characters),
55871 55871 # take no chances and rewrite it.
55872 55872 # Note: m4 eats our [], so we need to use [ and ] instead.
55873 55873 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
55874 55874 if test "x$has_forbidden_chars" != x; then
55875 55875 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
55876 55876 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
55877 55877 fi
55878 55878
55879 55879
55880 55880 windows_path="$new_path"
55881 55881 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
55882 55882 unix_path=`$CYGPATH -u "$windows_path"`
55883 55883 new_path="$unix_path"
55884 55884 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
55885 55885 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
55886 55886 new_path="$unix_path"
55887 55887 fi
55888 55888
55889 55889 if test "x$path" != "x$new_path"; then
55890 55890 MSVC_DLL="$new_path"
55891 55891 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
55892 55892 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
55893 55893 fi
55894 55894
55895 55895 # Save the first 10 bytes of this path to the storage, so fixpath can work.
55896 55896 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
55897 55897
55898 55898 else
55899 55899 # We're on a unix platform. Hooray! :)
55900 55900 path="$MSVC_DLL"
55901 55901 has_space=`$ECHO "$path" | $GREP " "`
55902 55902 if test "x$has_space" != x; then
55903 55903 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
55904 55904 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
55905 55905 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
55906 55906 fi
55907 55907
55908 55908 # Use eval to expand a potential ~
55909 55909 eval path="$path"
55910 55910 if test ! -f "$path" && test ! -d "$path"; then
55911 55911 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
55912 55912 fi
55913 55913
55914 55914 if test -d "$path"; then
55915 55915 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
55916 55916 else
55917 55917 dir="`$DIRNAME "$path"`"
55918 55918 base="`$BASENAME "$path"`"
55919 55919 MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
55920 55920 fi
55921 55921 fi
55922 55922 fi
55923 55923
55924 55924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55925 55925 $as_echo_n "checking for $DLL_NAME... " >&6; }
55926 55926 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
55927 55927 $as_echo "$MSVC_DLL" >&6; }
55928 55928 else
55929 55929 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
55930 55930 $as_echo "incorrect, ignoring" >&6; }
55931 55931 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
55932 55932 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
55933 55933 fi
55934 55934 fi
55935 55935
55936 55936 fi
55937 55937 fi
55938 55938
55939 55939 if test "x$MSVC_DLL" = x; then
55940 55940 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
55941 55941 $as_echo_n "checking for $DLL_NAME... " >&6; }
55942 55942 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
55943 55943 $as_echo "no" >&6; }
55944 55944 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
55945 55945 fi
55946 55946
55947 55947 MSVCP_DLL="$MSVC_DLL"
55948 55948 fi
55949 55949
55950 55950 fi
55951 55951
55952 55952 fi
55953 55953
55954 55954
55955 55955 if test "x$NEEDS_LIB_X11" = xfalse; then
55956 55956 if (test "x${with_x}" != x && test "x${with_x}" != xno); then
55957 55957 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: X11 is not used, so --with-x is ignored" >&5
55958 55958 $as_echo "$as_me: WARNING: X11 is not used, so --with-x is ignored" >&2;}
55959 55959 fi
55960 55960 X_CFLAGS=
55961 55961 X_LIBS=
55962 55962 else
55963 55963
55964 55964 if test "x${with_x}" = xno; then
55965 55965 as_fn_error $? "It is not possible to disable the use of X11. Remove the --without-x option." "$LINENO" 5
55966 55966 fi
55967 55967
55968 55968 if test "x${with_x}" != x && test "x${with_x}" != xyes; then
55969 55969 # The user has specified a X11 base directory. Use it for includes and
55970 55970 # libraries, unless explicitely overridden.
55971 55971 if test "x$x_includes" = xNONE; then
55972 55972 x_includes="${with_x}/include"
55973 55973 fi
55974 55974 if test "x$x_libraries" = xNONE; then
55975 55975 x_libraries="${with_x}/lib"
55976 55976 fi
55977 55977 else
55978 55978 # Check if the user has specified sysroot, but not --with-x, --x-includes or --x-libraries.
55979 55979 # Make a simple check for the libraries at the sysroot, and setup --x-includes and
55980 55980 # --x-libraries for the sysroot, if that seems to be correct.
55981 55981 if test "x$SYSROOT" != "x"; then
55982 55982 if test "x$x_includes" = xNONE; then
55983 55983 if test -f "$SYSROOT/usr/X11R6/include/X11/Xlib.h"; then
55984 55984 x_includes="$SYSROOT/usr/X11R6/include"
55985 55985 elif test -f "$SYSROOT/usr/include/X11/Xlib.h"; then
55986 55986 x_includes="$SYSROOT/usr/include"
55987 55987 fi
55988 55988 fi
55989 55989 if test "x$x_libraries" = xNONE; then
55990 55990 if test -f "$SYSROOT/usr/X11R6/lib/libX11.so"; then
55991 55991 x_libraries="$SYSROOT/usr/X11R6/lib"
55992 55992 elif test -f "$SYSROOT/usr/lib64/libX11.so" && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
55993 55993 x_libraries="$SYSROOT/usr/lib64"
55994 55994 elif test -f "$SYSROOT/usr/lib/libX11.so"; then
55995 55995 x_libraries="$SYSROOT/usr/lib"
55996 55996 fi
55997 55997 fi
55998 55998 fi
55999 55999 fi
56000 56000
56001 56001 # Now let autoconf do it's magic
56002 56002 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
56003 56003 $as_echo_n "checking for X... " >&6; }
56004 56004
56005 56005
56006 56006 # Check whether --with-x was given.
56007 56007 if test "${with_x+set}" = set; then :
56008 56008 withval=$with_x;
56009 56009 fi
56010 56010
56011 56011 # $have_x is `yes', `no', `disabled', or empty when we do not yet know.
56012 56012 if test "x$with_x" = xno; then
56013 56013 # The user explicitly disabled X.
56014 56014 have_x=disabled
56015 56015 else
56016 56016 case $x_includes,$x_libraries in #(
56017 56017 *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
56018 56018 *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
56019 56019 $as_echo_n "(cached) " >&6
56020 56020 else
56021 56021 # One or both of the vars are not set, and there is no cached value.
56022 56022 ac_x_includes=no ac_x_libraries=no
56023 56023 rm -f -r conftest.dir
56024 56024 if mkdir conftest.dir; then
56025 56025 cd conftest.dir
56026 56026 cat >Imakefile <<'_ACEOF'
56027 56027 incroot:
56028 56028 @echo incroot='${INCROOT}'
56029 56029 usrlibdir:
56030 56030 @echo usrlibdir='${USRLIBDIR}'
56031 56031 libdir:
56032 56032 @echo libdir='${LIBDIR}'
56033 56033 _ACEOF
56034 56034 if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
56035 56035 # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
56036 56036 for ac_var in incroot usrlibdir libdir; do
56037 56037 eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
56038 56038 done
56039 56039 # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
56040 56040 for ac_extension in a so sl dylib la dll; do
56041 56041 if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
56042 56042 test -f "$ac_im_libdir/libX11.$ac_extension"; then
56043 56043 ac_im_usrlibdir=$ac_im_libdir; break
56044 56044 fi
56045 56045 done
56046 56046 # Screen out bogus values from the imake configuration. They are
56047 56047 # bogus both because they are the default anyway, and because
56048 56048 # using them would break gcc on systems where it needs fixed includes.
56049 56049 case $ac_im_incroot in
56050 56050 /usr/include) ac_x_includes= ;;
56051 56051 *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
56052 56052 esac
56053 56053 case $ac_im_usrlibdir in
56054 56054 /usr/lib | /usr/lib64 | /lib | /lib64) ;;
56055 56055 *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
56056 56056 esac
56057 56057 fi
56058 56058 cd ..
56059 56059 rm -f -r conftest.dir
56060 56060 fi
56061 56061
56062 56062 # Standard set of common directories for X headers.
56063 56063 # Check X11 before X11Rn because it is often a symlink to the current release.
56064 56064 ac_x_header_dirs='
56065 56065 /usr/X11/include
56066 56066 /usr/X11R7/include
56067 56067 /usr/X11R6/include
56068 56068 /usr/X11R5/include
56069 56069 /usr/X11R4/include
56070 56070
56071 56071 /usr/include/X11
56072 56072 /usr/include/X11R7
56073 56073 /usr/include/X11R6
56074 56074 /usr/include/X11R5
56075 56075 /usr/include/X11R4
56076 56076
56077 56077 /usr/local/X11/include
56078 56078 /usr/local/X11R7/include
56079 56079 /usr/local/X11R6/include
56080 56080 /usr/local/X11R5/include
56081 56081 /usr/local/X11R4/include
56082 56082
56083 56083 /usr/local/include/X11
56084 56084 /usr/local/include/X11R7
56085 56085 /usr/local/include/X11R6
56086 56086 /usr/local/include/X11R5
56087 56087 /usr/local/include/X11R4
56088 56088
56089 56089 /usr/X386/include
56090 56090 /usr/x386/include
56091 56091 /usr/XFree86/include/X11
56092 56092
56093 56093 /usr/include
56094 56094 /usr/local/include
56095 56095 /usr/unsupported/include
56096 56096 /usr/athena/include
56097 56097 /usr/local/x11r5/include
56098 56098 /usr/lpp/Xamples/include
56099 56099
56100 56100 /usr/openwin/include
56101 56101 /usr/openwin/share/include'
56102 56102
56103 56103 if test "$ac_x_includes" = no; then
56104 56104 # Guess where to find include files, by looking for Xlib.h.
56105 56105 # First, try using that file with no special directory specified.
56106 56106 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56107 56107 /* end confdefs.h. */
56108 56108 #include <X11/Xlib.h>
56109 56109 _ACEOF
56110 56110 if ac_fn_cxx_try_cpp "$LINENO"; then :
56111 56111 # We can compile using X headers with no special include directory.
56112 56112 ac_x_includes=
56113 56113 else
56114 56114 for ac_dir in $ac_x_header_dirs; do
56115 56115 if test -r "$ac_dir/X11/Xlib.h"; then
56116 56116 ac_x_includes=$ac_dir
56117 56117 break
56118 56118 fi
56119 56119 done
56120 56120 fi
56121 56121 rm -f conftest.err conftest.i conftest.$ac_ext
56122 56122 fi # $ac_x_includes = no
56123 56123
56124 56124 if test "$ac_x_libraries" = no; then
56125 56125 # Check for the libraries.
56126 56126 # See if we find them without any special options.
56127 56127 # Don't add to $LIBS permanently.
56128 56128 ac_save_LIBS=$LIBS
56129 56129 LIBS="-lX11 $LIBS"
56130 56130 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56131 56131 /* end confdefs.h. */
56132 56132 #include <X11/Xlib.h>
56133 56133 int
56134 56134 main ()
56135 56135 {
56136 56136 XrmInitialize ()
56137 56137 ;
56138 56138 return 0;
56139 56139 }
56140 56140 _ACEOF
56141 56141 if ac_fn_cxx_try_link "$LINENO"; then :
56142 56142 LIBS=$ac_save_LIBS
56143 56143 # We can link X programs with no special library path.
56144 56144 ac_x_libraries=
56145 56145 else
56146 56146 LIBS=$ac_save_LIBS
56147 56147 for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
56148 56148 do
56149 56149 # Don't even attempt the hair of trying to link an X program!
56150 56150 for ac_extension in a so sl dylib la dll; do
56151 56151 if test -r "$ac_dir/libX11.$ac_extension"; then
56152 56152 ac_x_libraries=$ac_dir
56153 56153 break 2
56154 56154 fi
56155 56155 done
56156 56156 done
56157 56157 fi
56158 56158 rm -f core conftest.err conftest.$ac_objext \
56159 56159 conftest$ac_exeext conftest.$ac_ext
56160 56160 fi # $ac_x_libraries = no
56161 56161
56162 56162 case $ac_x_includes,$ac_x_libraries in #(
56163 56163 no,* | *,no | *\'*)
56164 56164 # Didn't find X, or a directory has "'" in its name.
56165 56165 ac_cv_have_x="have_x=no";; #(
56166 56166 *)
56167 56167 # Record where we found X for the cache.
56168 56168 ac_cv_have_x="have_x=yes\
56169 56169 ac_x_includes='$ac_x_includes'\
56170 56170 ac_x_libraries='$ac_x_libraries'"
56171 56171 esac
56172 56172 fi
56173 56173 ;; #(
56174 56174 *) have_x=yes;;
56175 56175 esac
56176 56176 eval "$ac_cv_have_x"
56177 56177 fi # $with_x != no
56178 56178
56179 56179 if test "$have_x" != yes; then
56180 56180 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
56181 56181 $as_echo "$have_x" >&6; }
56182 56182 no_x=yes
56183 56183 else
56184 56184 # If each of the values was on the command line, it overrides each guess.
56185 56185 test "x$x_includes" = xNONE && x_includes=$ac_x_includes
56186 56186 test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
56187 56187 # Update the cache value to reflect the command line values.
56188 56188 ac_cv_have_x="have_x=yes\
56189 56189 ac_x_includes='$x_includes'\
56190 56190 ac_x_libraries='$x_libraries'"
56191 56191 { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
56192 56192 $as_echo "libraries $x_libraries, headers $x_includes" >&6; }
56193 56193 fi
56194 56194
56195 56195 if test "$no_x" = yes; then
56196 56196 # Not all programs may use this symbol, but it does not hurt to define it.
56197 56197
56198 56198 $as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
56199 56199
56200 56200 X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
56201 56201 else
56202 56202 if test -n "$x_includes"; then
56203 56203 X_CFLAGS="$X_CFLAGS -I$x_includes"
56204 56204 fi
56205 56205
56206 56206 # It would also be nice to do this for all -L options, not just this one.
56207 56207 if test -n "$x_libraries"; then
56208 56208 X_LIBS="$X_LIBS -L$x_libraries"
56209 56209 # For Solaris; some versions of Sun CC require a space after -R and
56210 56210 # others require no space. Words are not sufficient . . . .
56211 56211 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
56212 56212 $as_echo_n "checking whether -R must be followed by a space... " >&6; }
56213 56213 ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
56214 56214 ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag
56215 56215 ac_cxx_werror_flag=yes
56216 56216 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56217 56217 /* end confdefs.h. */
56218 56218
56219 56219 int
56220 56220 main ()
56221 56221 {
56222 56222
56223 56223 ;
56224 56224 return 0;
56225 56225 }
56226 56226 _ACEOF
56227 56227 if ac_fn_cxx_try_link "$LINENO"; then :
56228 56228 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
56229 56229 $as_echo "no" >&6; }
56230 56230 X_LIBS="$X_LIBS -R$x_libraries"
56231 56231 else
56232 56232 LIBS="$ac_xsave_LIBS -R $x_libraries"
56233 56233 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56234 56234 /* end confdefs.h. */
56235 56235
56236 56236 int
56237 56237 main ()
56238 56238 {
56239 56239
56240 56240 ;
56241 56241 return 0;
56242 56242 }
56243 56243 _ACEOF
56244 56244 if ac_fn_cxx_try_link "$LINENO"; then :
56245 56245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
56246 56246 $as_echo "yes" >&6; }
56247 56247 X_LIBS="$X_LIBS -R $x_libraries"
56248 56248 else
56249 56249 { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
56250 56250 $as_echo "neither works" >&6; }
56251 56251 fi
56252 56252 rm -f core conftest.err conftest.$ac_objext \
56253 56253 conftest$ac_exeext conftest.$ac_ext
56254 56254 fi
56255 56255 rm -f core conftest.err conftest.$ac_objext \
56256 56256 conftest$ac_exeext conftest.$ac_ext
56257 56257 ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag
56258 56258 LIBS=$ac_xsave_LIBS
56259 56259 fi
56260 56260
56261 56261 # Check for system-dependent libraries X programs must link with.
56262 56262 # Do this before checking for the system-independent R6 libraries
56263 56263 # (-lICE), since we may need -lsocket or whatever for X linking.
56264 56264
56265 56265 if test "$ISC" = yes; then
56266 56266 X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet"
56267 56267 else
56268 56268 # Martyn Johnson says this is needed for Ultrix, if the X
56269 56269 # libraries were built with DECnet support. And Karl Berry says
56270 56270 # the Alpha needs dnet_stub (dnet does not exist).
56271 56271 ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11"
56272 56272 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56273 56273 /* end confdefs.h. */
56274 56274
56275 56275 /* Override any GCC internal prototype to avoid an error.
56276 56276 Use char because int might match the return type of a GCC
56277 56277 builtin and then its argument prototype would still apply. */
56278 56278 #ifdef __cplusplus
56279 56279 extern "C"
56280 56280 #endif
56281 56281 char XOpenDisplay ();
56282 56282 int
56283 56283 main ()
56284 56284 {
56285 56285 return XOpenDisplay ();
56286 56286 ;
56287 56287 return 0;
56288 56288 }
56289 56289 _ACEOF
56290 56290 if ac_fn_cxx_try_link "$LINENO"; then :
56291 56291
56292 56292 else
56293 56293 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
56294 56294 $as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
56295 56295 if ${ac_cv_lib_dnet_dnet_ntoa+:} false; then :
56296 56296 $as_echo_n "(cached) " >&6
56297 56297 else
56298 56298 ac_check_lib_save_LIBS=$LIBS
56299 56299 LIBS="-ldnet $LIBS"
56300 56300 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56301 56301 /* end confdefs.h. */
56302 56302
56303 56303 /* Override any GCC internal prototype to avoid an error.
56304 56304 Use char because int might match the return type of a GCC
56305 56305 builtin and then its argument prototype would still apply. */
56306 56306 #ifdef __cplusplus
56307 56307 extern "C"
56308 56308 #endif
56309 56309 char dnet_ntoa ();
56310 56310 int
56311 56311 main ()
56312 56312 {
56313 56313 return dnet_ntoa ();
56314 56314 ;
56315 56315 return 0;
56316 56316 }
56317 56317 _ACEOF
56318 56318 if ac_fn_cxx_try_link "$LINENO"; then :
56319 56319 ac_cv_lib_dnet_dnet_ntoa=yes
56320 56320 else
56321 56321 ac_cv_lib_dnet_dnet_ntoa=no
56322 56322 fi
56323 56323 rm -f core conftest.err conftest.$ac_objext \
56324 56324 conftest$ac_exeext conftest.$ac_ext
56325 56325 LIBS=$ac_check_lib_save_LIBS
56326 56326 fi
56327 56327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
56328 56328 $as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
56329 56329 if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes; then :
56330 56330 X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
56331 56331 fi
56332 56332
56333 56333 if test $ac_cv_lib_dnet_dnet_ntoa = no; then
56334 56334 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
56335 56335 $as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
56336 56336 if ${ac_cv_lib_dnet_stub_dnet_ntoa+:} false; then :
56337 56337 $as_echo_n "(cached) " >&6
56338 56338 else
56339 56339 ac_check_lib_save_LIBS=$LIBS
56340 56340 LIBS="-ldnet_stub $LIBS"
56341 56341 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56342 56342 /* end confdefs.h. */
56343 56343
56344 56344 /* Override any GCC internal prototype to avoid an error.
56345 56345 Use char because int might match the return type of a GCC
56346 56346 builtin and then its argument prototype would still apply. */
56347 56347 #ifdef __cplusplus
56348 56348 extern "C"
56349 56349 #endif
56350 56350 char dnet_ntoa ();
56351 56351 int
56352 56352 main ()
56353 56353 {
56354 56354 return dnet_ntoa ();
56355 56355 ;
56356 56356 return 0;
56357 56357 }
56358 56358 _ACEOF
56359 56359 if ac_fn_cxx_try_link "$LINENO"; then :
56360 56360 ac_cv_lib_dnet_stub_dnet_ntoa=yes
56361 56361 else
56362 56362 ac_cv_lib_dnet_stub_dnet_ntoa=no
56363 56363 fi
56364 56364 rm -f core conftest.err conftest.$ac_objext \
56365 56365 conftest$ac_exeext conftest.$ac_ext
56366 56366 LIBS=$ac_check_lib_save_LIBS
56367 56367 fi
56368 56368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
56369 56369 $as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
56370 56370 if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes; then :
56371 56371 X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
56372 56372 fi
56373 56373
56374 56374 fi
56375 56375 fi
56376 56376 rm -f core conftest.err conftest.$ac_objext \
56377 56377 conftest$ac_exeext conftest.$ac_ext
56378 56378 LIBS="$ac_xsave_LIBS"
56379 56379
56380 56380 # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,
56381 56381 # to get the SysV transport functions.
56382 56382 # Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4)
56383 56383 # needs -lnsl.
56384 56384 # The nsl library prevents programs from opening the X display
56385 56385 # on Irix 5.2, according to T.E. Dickey.
56386 56386 # The functions gethostbyname, getservbyname, and inet_addr are
56387 56387 # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
56388 56388 ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
56389 56389 if test "x$ac_cv_func_gethostbyname" = xyes; then :
56390 56390
56391 56391 fi
56392 56392
56393 56393 if test $ac_cv_func_gethostbyname = no; then
56394 56394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
56395 56395 $as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
56396 56396 if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
56397 56397 $as_echo_n "(cached) " >&6
56398 56398 else
56399 56399 ac_check_lib_save_LIBS=$LIBS
56400 56400 LIBS="-lnsl $LIBS"
56401 56401 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56402 56402 /* end confdefs.h. */
56403 56403
56404 56404 /* Override any GCC internal prototype to avoid an error.
56405 56405 Use char because int might match the return type of a GCC
56406 56406 builtin and then its argument prototype would still apply. */
56407 56407 #ifdef __cplusplus
56408 56408 extern "C"
56409 56409 #endif
56410 56410 char gethostbyname ();
56411 56411 int
56412 56412 main ()
56413 56413 {
56414 56414 return gethostbyname ();
56415 56415 ;
56416 56416 return 0;
56417 56417 }
56418 56418 _ACEOF
56419 56419 if ac_fn_cxx_try_link "$LINENO"; then :
56420 56420 ac_cv_lib_nsl_gethostbyname=yes
56421 56421 else
56422 56422 ac_cv_lib_nsl_gethostbyname=no
56423 56423 fi
56424 56424 rm -f core conftest.err conftest.$ac_objext \
56425 56425 conftest$ac_exeext conftest.$ac_ext
56426 56426 LIBS=$ac_check_lib_save_LIBS
56427 56427 fi
56428 56428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
56429 56429 $as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
56430 56430 if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
56431 56431 X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
56432 56432 fi
56433 56433
56434 56434 if test $ac_cv_lib_nsl_gethostbyname = no; then
56435 56435 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
56436 56436 $as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
56437 56437 if ${ac_cv_lib_bsd_gethostbyname+:} false; then :
56438 56438 $as_echo_n "(cached) " >&6
56439 56439 else
56440 56440 ac_check_lib_save_LIBS=$LIBS
56441 56441 LIBS="-lbsd $LIBS"
56442 56442 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56443 56443 /* end confdefs.h. */
56444 56444
56445 56445 /* Override any GCC internal prototype to avoid an error.
56446 56446 Use char because int might match the return type of a GCC
56447 56447 builtin and then its argument prototype would still apply. */
56448 56448 #ifdef __cplusplus
56449 56449 extern "C"
56450 56450 #endif
56451 56451 char gethostbyname ();
56452 56452 int
56453 56453 main ()
56454 56454 {
56455 56455 return gethostbyname ();
56456 56456 ;
56457 56457 return 0;
56458 56458 }
56459 56459 _ACEOF
56460 56460 if ac_fn_cxx_try_link "$LINENO"; then :
56461 56461 ac_cv_lib_bsd_gethostbyname=yes
56462 56462 else
56463 56463 ac_cv_lib_bsd_gethostbyname=no
56464 56464 fi
56465 56465 rm -f core conftest.err conftest.$ac_objext \
56466 56466 conftest$ac_exeext conftest.$ac_ext
56467 56467 LIBS=$ac_check_lib_save_LIBS
56468 56468 fi
56469 56469 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
56470 56470 $as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
56471 56471 if test "x$ac_cv_lib_bsd_gethostbyname" = xyes; then :
56472 56472 X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
56473 56473 fi
56474 56474
56475 56475 fi
56476 56476 fi
56477 56477
56478 56478 # lieder@skyler.mavd.honeywell.com says without -lsocket,
56479 56479 # socket/setsockopt and other routines are undefined under SCO ODT
56480 56480 # 2.0. But -lsocket is broken on IRIX 5.2 (and is not necessary
56481 56481 # on later versions), says Simon Leinen: it contains gethostby*
56482 56482 # variants that don't use the name server (or something). -lsocket
56483 56483 # must be given before -lnsl if both are needed. We assume that
56484 56484 # if connect needs -lnsl, so does gethostbyname.
56485 56485 ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect"
56486 56486 if test "x$ac_cv_func_connect" = xyes; then :
56487 56487
56488 56488 fi
56489 56489
56490 56490 if test $ac_cv_func_connect = no; then
56491 56491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
56492 56492 $as_echo_n "checking for connect in -lsocket... " >&6; }
56493 56493 if ${ac_cv_lib_socket_connect+:} false; then :
56494 56494 $as_echo_n "(cached) " >&6
56495 56495 else
56496 56496 ac_check_lib_save_LIBS=$LIBS
56497 56497 LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
56498 56498 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56499 56499 /* end confdefs.h. */
56500 56500
56501 56501 /* Override any GCC internal prototype to avoid an error.
56502 56502 Use char because int might match the return type of a GCC
56503 56503 builtin and then its argument prototype would still apply. */
56504 56504 #ifdef __cplusplus
56505 56505 extern "C"
56506 56506 #endif
56507 56507 char connect ();
56508 56508 int
56509 56509 main ()
56510 56510 {
56511 56511 return connect ();
56512 56512 ;
56513 56513 return 0;
56514 56514 }
56515 56515 _ACEOF
56516 56516 if ac_fn_cxx_try_link "$LINENO"; then :
56517 56517 ac_cv_lib_socket_connect=yes
56518 56518 else
56519 56519 ac_cv_lib_socket_connect=no
56520 56520 fi
56521 56521 rm -f core conftest.err conftest.$ac_objext \
56522 56522 conftest$ac_exeext conftest.$ac_ext
56523 56523 LIBS=$ac_check_lib_save_LIBS
56524 56524 fi
56525 56525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
56526 56526 $as_echo "$ac_cv_lib_socket_connect" >&6; }
56527 56527 if test "x$ac_cv_lib_socket_connect" = xyes; then :
56528 56528 X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
56529 56529 fi
56530 56530
56531 56531 fi
56532 56532
56533 56533 # Guillermo Gomez says -lposix is necessary on A/UX.
56534 56534 ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove"
56535 56535 if test "x$ac_cv_func_remove" = xyes; then :
56536 56536
56537 56537 fi
56538 56538
56539 56539 if test $ac_cv_func_remove = no; then
56540 56540 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
56541 56541 $as_echo_n "checking for remove in -lposix... " >&6; }
56542 56542 if ${ac_cv_lib_posix_remove+:} false; then :
56543 56543 $as_echo_n "(cached) " >&6
56544 56544 else
56545 56545 ac_check_lib_save_LIBS=$LIBS
56546 56546 LIBS="-lposix $LIBS"
56547 56547 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56548 56548 /* end confdefs.h. */
56549 56549
56550 56550 /* Override any GCC internal prototype to avoid an error.
56551 56551 Use char because int might match the return type of a GCC
56552 56552 builtin and then its argument prototype would still apply. */
56553 56553 #ifdef __cplusplus
56554 56554 extern "C"
56555 56555 #endif
56556 56556 char remove ();
56557 56557 int
56558 56558 main ()
56559 56559 {
56560 56560 return remove ();
56561 56561 ;
56562 56562 return 0;
56563 56563 }
56564 56564 _ACEOF
56565 56565 if ac_fn_cxx_try_link "$LINENO"; then :
56566 56566 ac_cv_lib_posix_remove=yes
56567 56567 else
56568 56568 ac_cv_lib_posix_remove=no
56569 56569 fi
56570 56570 rm -f core conftest.err conftest.$ac_objext \
56571 56571 conftest$ac_exeext conftest.$ac_ext
56572 56572 LIBS=$ac_check_lib_save_LIBS
56573 56573 fi
56574 56574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
56575 56575 $as_echo "$ac_cv_lib_posix_remove" >&6; }
56576 56576 if test "x$ac_cv_lib_posix_remove" = xyes; then :
56577 56577 X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
56578 56578 fi
56579 56579
56580 56580 fi
56581 56581
56582 56582 # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
56583 56583 ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
56584 56584 if test "x$ac_cv_func_shmat" = xyes; then :
56585 56585
56586 56586 fi
56587 56587
56588 56588 if test $ac_cv_func_shmat = no; then
56589 56589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
56590 56590 $as_echo_n "checking for shmat in -lipc... " >&6; }
56591 56591 if ${ac_cv_lib_ipc_shmat+:} false; then :
56592 56592 $as_echo_n "(cached) " >&6
56593 56593 else
56594 56594 ac_check_lib_save_LIBS=$LIBS
56595 56595 LIBS="-lipc $LIBS"
56596 56596 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56597 56597 /* end confdefs.h. */
56598 56598
56599 56599 /* Override any GCC internal prototype to avoid an error.
56600 56600 Use char because int might match the return type of a GCC
56601 56601 builtin and then its argument prototype would still apply. */
56602 56602 #ifdef __cplusplus
56603 56603 extern "C"
56604 56604 #endif
56605 56605 char shmat ();
56606 56606 int
56607 56607 main ()
56608 56608 {
56609 56609 return shmat ();
56610 56610 ;
56611 56611 return 0;
56612 56612 }
56613 56613 _ACEOF
56614 56614 if ac_fn_cxx_try_link "$LINENO"; then :
56615 56615 ac_cv_lib_ipc_shmat=yes
56616 56616 else
56617 56617 ac_cv_lib_ipc_shmat=no
56618 56618 fi
56619 56619 rm -f core conftest.err conftest.$ac_objext \
56620 56620 conftest$ac_exeext conftest.$ac_ext
56621 56621 LIBS=$ac_check_lib_save_LIBS
56622 56622 fi
56623 56623 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
56624 56624 $as_echo "$ac_cv_lib_ipc_shmat" >&6; }
56625 56625 if test "x$ac_cv_lib_ipc_shmat" = xyes; then :
56626 56626 X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
56627 56627 fi
56628 56628
56629 56629 fi
56630 56630 fi
56631 56631
56632 56632 # Check for libraries that X11R6 Xt/Xaw programs need.
56633 56633 ac_save_LDFLAGS=$LDFLAGS
56634 56634 test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries"
56635 56635 # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to
56636 56636 # check for ICE first), but we must link in the order -lSM -lICE or
56637 56637 # we get undefined symbols. So assume we have SM if we have ICE.
56638 56638 # These have to be linked with before -lX11, unlike the other
56639 56639 # libraries we check for below, so use a different variable.
56640 56640 # John Interrante, Karl Berry
56641 56641 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
56642 56642 $as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
56643 56643 if ${ac_cv_lib_ICE_IceConnectionNumber+:} false; then :
56644 56644 $as_echo_n "(cached) " >&6
56645 56645 else
56646 56646 ac_check_lib_save_LIBS=$LIBS
56647 56647 LIBS="-lICE $X_EXTRA_LIBS $LIBS"
56648 56648 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56649 56649 /* end confdefs.h. */
56650 56650
56651 56651 /* Override any GCC internal prototype to avoid an error.
56652 56652 Use char because int might match the return type of a GCC
56653 56653 builtin and then its argument prototype would still apply. */
56654 56654 #ifdef __cplusplus
56655 56655 extern "C"
56656 56656 #endif
56657 56657 char IceConnectionNumber ();
56658 56658 int
56659 56659 main ()
56660 56660 {
56661 56661 return IceConnectionNumber ();
56662 56662 ;
56663 56663 return 0;
56664 56664 }
56665 56665 _ACEOF
56666 56666 if ac_fn_cxx_try_link "$LINENO"; then :
56667 56667 ac_cv_lib_ICE_IceConnectionNumber=yes
56668 56668 else
56669 56669 ac_cv_lib_ICE_IceConnectionNumber=no
56670 56670 fi
56671 56671 rm -f core conftest.err conftest.$ac_objext \
56672 56672 conftest$ac_exeext conftest.$ac_ext
56673 56673 LIBS=$ac_check_lib_save_LIBS
56674 56674 fi
56675 56675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
56676 56676 $as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
56677 56677 if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes; then :
56678 56678 X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
56679 56679 fi
56680 56680
56681 56681 LDFLAGS=$ac_save_LDFLAGS
56682 56682
56683 56683 fi
56684 56684
56685 56685
56686 56686 # AC_PATH_XTRA creates X_LIBS and sometimes adds -R flags. When cross compiling
56687 56687 # this doesn't make sense so we remove it.
56688 56688 if test "x$COMPILE_TYPE" = xcross; then
56689 56689 X_LIBS=`$ECHO $X_LIBS | $SED 's/-R \{0,1\}[^ ]*//g'`
56690 56690 fi
56691 56691
56692 56692 if test "x$no_x" = xyes; then
56693 56693
56694 56694 # Print a helpful message on how to acquire the necessary build dependency.
56695 56695 # x11 is the help tag: freetype, cups, alsa etc
56696 56696 MISSING_DEPENDENCY=x11
56697 56697
56698 56698 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
56699 56699 cygwin_help $MISSING_DEPENDENCY
56700 56700 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
56701 56701 msys_help $MISSING_DEPENDENCY
56702 56702 else
56703 56703 PKGHANDLER_COMMAND=
56704 56704
56705 56705 case $PKGHANDLER in
56706 56706 apt-get)
56707 56707 apt_help $MISSING_DEPENDENCY ;;
56708 56708 yum)
56709 56709 yum_help $MISSING_DEPENDENCY ;;
56710 56710 port)
56711 56711 port_help $MISSING_DEPENDENCY ;;
56712 56712 pkgutil)
56713 56713 pkgutil_help $MISSING_DEPENDENCY ;;
56714 56714 pkgadd)
56715 56715 pkgadd_help $MISSING_DEPENDENCY ;;
56716 56716 esac
56717 56717
56718 56718 if test "x$PKGHANDLER_COMMAND" != x; then
56719 56719 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
56720 56720 fi
56721 56721 fi
56722 56722
56723 56723 as_fn_error $? "Could not find X11 libraries. $HELP_MSG" "$LINENO" 5
56724 56724 fi
56725 56725
56726 56726 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
56727 56727 OPENWIN_HOME="/usr/openwin"
56728 56728 X_CFLAGS="-I$SYSROOT$OPENWIN_HOME/include -I$SYSROOT$OPENWIN_HOME/include/X11/extensions"
56729 56729 X_LIBS="-L$SYSROOT$OPENWIN_HOME/sfw/lib$OPENJDK_TARGET_CPU_ISADIR \
56730 56730 -L$SYSROOT$OPENWIN_HOME/lib$OPENJDK_TARGET_CPU_ISADIR \
56731 56731 -R$OPENWIN_HOME/sfw/lib$OPENJDK_TARGET_CPU_ISADIR \
56732 56732 -R$OPENWIN_HOME/lib$OPENJDK_TARGET_CPU_ISADIR"
56733 56733 fi
56734 56734
56735 56735 ac_ext=c
56736 56736 ac_cpp='$CPP $CPPFLAGS'
56737 56737 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
56738 56738 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
56739 56739 ac_compiler_gnu=$ac_cv_c_compiler_gnu
56740 56740
56741 56741 OLD_CFLAGS="$CFLAGS"
56742 56742 CFLAGS="$CFLAGS $SYSROOT_CFLAGS $X_CFLAGS"
56743 56743
56744 56744 # Need to include Xlib.h and Xutil.h to avoid "present but cannot be compiled" warnings on Solaris 10
56745 56745 for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
56746 56746 do :
56747 56747 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
56748 56748 ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "
56749 56749 # include <X11/Xlib.h>
56750 56750 # include <X11/Xutil.h>
56751 56751
56752 56752
56753 56753 "
56754 56754 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
56755 56755 cat >>confdefs.h <<_ACEOF
56756 56756 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
56757 56757 _ACEOF
56758 56758 X11_HEADERS_OK=yes
56759 56759 else
56760 56760 X11_HEADERS_OK=no; break
56761 56761 fi
56762 56762
56763 56763 done
56764 56764
56765 56765
56766 56766 if test "x$X11_HEADERS_OK" = xno; then
56767 56767
56768 56768 # Print a helpful message on how to acquire the necessary build dependency.
56769 56769 # x11 is the help tag: freetype, cups, alsa etc
56770 56770 MISSING_DEPENDENCY=x11
56771 56771
56772 56772 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
56773 56773 cygwin_help $MISSING_DEPENDENCY
56774 56774 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
56775 56775 msys_help $MISSING_DEPENDENCY
56776 56776 else
56777 56777 PKGHANDLER_COMMAND=
56778 56778
56779 56779 case $PKGHANDLER in
56780 56780 apt-get)
56781 56781 apt_help $MISSING_DEPENDENCY ;;
56782 56782 yum)
56783 56783 yum_help $MISSING_DEPENDENCY ;;
56784 56784 port)
56785 56785 port_help $MISSING_DEPENDENCY ;;
56786 56786 pkgutil)
56787 56787 pkgutil_help $MISSING_DEPENDENCY ;;
56788 56788 pkgadd)
56789 56789 pkgadd_help $MISSING_DEPENDENCY ;;
56790 56790 esac
56791 56791
56792 56792 if test "x$PKGHANDLER_COMMAND" != x; then
56793 56793 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
56794 56794 fi
56795 56795 fi
56796 56796
56797 56797 as_fn_error $? "Could not find all X11 headers (shape.h Xrender.h XTest.h Intrinsic.h). $HELP_MSG" "$LINENO" 5
56798 56798 fi
56799 56799
56800 56800 # If XLinearGradient isn't available in Xrender.h, signal that it needs to be
56801 56801 # defined in libawt_xawt.
56802 56802 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if XlinearGradient is defined in Xrender.h" >&5
56803 56803 $as_echo_n "checking if XlinearGradient is defined in Xrender.h... " >&6; }
56804 56804 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
56805 56805 /* end confdefs.h. */
56806 56806 #include <X11/extensions/Xrender.h>
56807 56807 int
56808 56808 main ()
56809 56809 {
56810 56810 XLinearGradient x;
56811 56811 ;
56812 56812 return 0;
56813 56813 }
56814 56814 _ACEOF
56815 56815 if ac_fn_c_try_compile "$LINENO"; then :
56816 56816 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
56817 56817 $as_echo "yes" >&6; }
56818 56818 else
56819 56819 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
56820 56820 $as_echo "no" >&6; }
56821 56821 X_CFLAGS="$X_CFLAGS -DSOLARIS10_NO_XRENDER_STRUCTS"
56822 56822 fi
56823 56823 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
56824 56824
56825 56825 CFLAGS="$OLD_CFLAGS"
56826 56826 ac_ext=cpp
56827 56827 ac_cpp='$CXXCPP $CPPFLAGS'
56828 56828 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
56829 56829 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
56830 56830 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
56831 56831
56832 56832 fi # NEEDS_LIB_X11
56833 56833
56834 56834
56835 56835
56836 56836
56837 56837
56838 56838
56839 56839 # Check whether --with-cups was given.
56840 56840 if test "${with_cups+set}" = set; then :
56841 56841 withval=$with_cups;
56842 56842 fi
56843 56843
56844 56844
56845 56845 # Check whether --with-cups-include was given.
56846 56846 if test "${with_cups_include+set}" = set; then :
56847 56847 withval=$with_cups_include;
56848 56848 fi
56849 56849
56850 56850
56851 56851 if test "x$NEEDS_LIB_CUPS" = xfalse; then
56852 56852 if (test "x${with_cups}" != x && test "x${with_cups}" != xno) || \
56853 56853 (test "x${with_cups_include}" != x && test "x${with_cups_include}" != xno); then
56854 56854 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups[-*] is ignored" >&5
56855 56855 $as_echo "$as_me: WARNING: cups not used, so --with-cups[-*] is ignored" >&2;}
56856 56856 fi
56857 56857 CUPS_CFLAGS=
56858 56858 else
56859 56859 CUPS_FOUND=no
56860 56860
56861 56861 if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno; then
56862 56862 as_fn_error $? "It is not possible to disable the use of cups. Remove the --without-cups option." "$LINENO" 5
56863 56863 fi
56864 56864
56865 56865 if test "x${with_cups}" != x; then
56866 56866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
56867 56867 $as_echo_n "checking for cups headers... " >&6; }
56868 56868 if test -s "${with_cups}/include/cups/cups.h"; then
56869 56869 CUPS_CFLAGS="-I${with_cups}/include"
56870 56870 CUPS_FOUND=yes
56871 56871 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
56872 56872 $as_echo "$CUPS_FOUND" >&6; }
56873 56873 else
56874 56874 as_fn_error $? "Can't find 'include/cups/cups.h' under ${with_cups} given with the --with-cups option." "$LINENO" 5
56875 56875 fi
56876 56876 fi
56877 56877 if test "x${with_cups_include}" != x; then
56878 56878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
56879 56879 $as_echo_n "checking for cups headers... " >&6; }
56880 56880 if test -s "${with_cups_include}/cups/cups.h"; then
56881 56881 CUPS_CFLAGS="-I${with_cups_include}"
56882 56882 CUPS_FOUND=yes
56883 56883 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
56884 56884 $as_echo "$CUPS_FOUND" >&6; }
56885 56885 else
56886 56886 as_fn_error $? "Can't find 'cups/cups.h' under ${with_cups_include} given with the --with-cups-include option." "$LINENO" 5
56887 56887 fi
56888 56888 fi
56889 56889 if test "x$CUPS_FOUND" = xno; then
56890 56890 # Are the cups headers installed in the default /usr/include location?
56891 56891 for ac_header in cups/cups.h cups/ppd.h
56892 56892 do :
56893 56893 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
56894 56894 ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
56895 56895 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
56896 56896 cat >>confdefs.h <<_ACEOF
56897 56897 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
56898 56898 _ACEOF
56899 56899
|
↓ open down ↓ |
51791 lines elided |
↑ open up ↑ |
56900 56900 CUPS_FOUND=yes
56901 56901 CUPS_CFLAGS=
56902 56902 DEFAULT_CUPS=yes
56903 56903
56904 56904 fi
56905 56905
56906 56906 done
56907 56907
56908 56908 fi
56909 56909 if test "x$CUPS_FOUND" = xno; then
56910 - # Getting nervous now? Lets poke around for standard Solaris third-party
56911 - # package installation locations.
56912 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
56913 -$as_echo_n "checking for cups headers... " >&6; }
56914 - if test -s $SYSROOT/opt/sfw/cups/include/cups/cups.h; then
56915 - # An SFW package seems to be installed!
56916 - CUPS_FOUND=yes
56917 - CUPS_CFLAGS="-I$SYSROOT/opt/sfw/cups/include"
56918 - elif test -s $SYSROOT/opt/csw/include/cups/cups.h; then
56919 - # A CSW package seems to be installed!
56920 - CUPS_FOUND=yes
56921 - CUPS_CFLAGS="-I$SYSROOT/opt/csw/include"
56922 - fi
56923 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
56924 -$as_echo "$CUPS_FOUND" >&6; }
56925 - fi
56926 - if test "x$CUPS_FOUND" = xno; then
56927 56910
56928 56911 # Print a helpful message on how to acquire the necessary build dependency.
56929 56912 # cups is the help tag: freetype, cups, alsa etc
56930 56913 MISSING_DEPENDENCY=cups
56931 56914
56932 56915 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
56933 56916 cygwin_help $MISSING_DEPENDENCY
56934 56917 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
56935 56918 msys_help $MISSING_DEPENDENCY
56936 56919 else
56937 56920 PKGHANDLER_COMMAND=
56938 56921
56939 56922 case $PKGHANDLER in
56940 56923 apt-get)
56941 56924 apt_help $MISSING_DEPENDENCY ;;
56942 56925 yum)
56943 56926 yum_help $MISSING_DEPENDENCY ;;
56944 56927 port)
56945 56928 port_help $MISSING_DEPENDENCY ;;
56946 56929 pkgutil)
56947 56930 pkgutil_help $MISSING_DEPENDENCY ;;
56948 56931 pkgadd)
56949 56932 pkgadd_help $MISSING_DEPENDENCY ;;
56950 56933 esac
56951 56934
56952 56935 if test "x$PKGHANDLER_COMMAND" != x; then
56953 56936 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
56954 56937 fi
56955 56938 fi
56956 56939
56957 56940 as_fn_error $? "Could not find cups! $HELP_MSG " "$LINENO" 5
56958 56941 fi
56959 56942 fi
56960 56943
56961 56944
56962 56945
56963 56946
56964 56947
56965 56948 # Check whether --with-freetype was given.
56966 56949 if test "${with_freetype+set}" = set; then :
56967 56950 withval=$with_freetype;
56968 56951 fi
56969 56952
56970 56953
56971 56954 # Check whether --with-freetype-include was given.
56972 56955 if test "${with_freetype_include+set}" = set; then :
56973 56956 withval=$with_freetype_include;
56974 56957 fi
56975 56958
56976 56959
56977 56960 # Check whether --with-freetype-lib was given.
56978 56961 if test "${with_freetype_lib+set}" = set; then :
56979 56962 withval=$with_freetype_lib;
56980 56963 fi
56981 56964
56982 56965
56983 56966 # Check whether --with-freetype-src was given.
56984 56967 if test "${with_freetype_src+set}" = set; then :
56985 56968 withval=$with_freetype_src;
56986 56969 fi
56987 56970
56988 56971 # Check whether --enable-freetype-bundling was given.
56989 56972 if test "${enable_freetype_bundling+set}" = set; then :
56990 56973 enableval=$enable_freetype_bundling;
56991 56974 fi
56992 56975
56993 56976
56994 56977 # Need to specify explicitly since it needs to be overridden on some versions of macosx
56995 56978 FREETYPE_BASE_NAME=freetype
56996 56979 FREETYPE_CFLAGS=
56997 56980 FREETYPE_LIBS=
56998 56981 FREETYPE_BUNDLE_LIB_PATH=
56999 56982
57000 56983 if test "x$NEEDS_LIB_FREETYPE" = xfalse; then
57001 56984 if (test "x$with_freetype" != x && test "x$with_freetype" != xno) || \
57002 56985 (test "x$with_freetype_include" != x && test "x$with_freetype_include" != xno) || \
57003 56986 (test "x$with_freetype_lib" != x && test "x$with_freetype_lib" != xno) || \
57004 56987 (test "x$with_freetype_src" != x && test "x$with_freetype_src" != xno); then
57005 56988 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --with-freetype[-*] is ignored" >&5
57006 56989 $as_echo "$as_me: WARNING: freetype not used, so --with-freetype[-*] is ignored" >&2;}
57007 56990 fi
57008 56991 if (test "x$enable_freetype_bundling" != x && test "x$enable_freetype_bundling" != xno); then
57009 56992 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --enable-freetype-bundling is ignored" >&5
57010 56993 $as_echo "$as_me: WARNING: freetype not used, so --enable-freetype-bundling is ignored" >&2;}
57011 56994 fi
57012 56995 else
57013 56996 # freetype is needed to build; go get it!
57014 56997
57015 56998 BUNDLE_FREETYPE="$enable_freetype_bundling"
57016 56999
57017 57000 if test "x$with_freetype_src" != x; then
57018 57001 if test "x$OPENJDK_TARGET_OS" = xwindows; then
57019 57002 # Try to build freetype if --with-freetype-src was given on Windows
57020 57003
57021 57004 FREETYPE_SRC_PATH="$with_freetype_src"
57022 57005 BUILD_FREETYPE=yes
57023 57006
57024 57007 # Check if the freetype sources are acessible..
57025 57008 if ! test -d $FREETYPE_SRC_PATH; then
57026 57009 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&5
57027 57010 $as_echo "$as_me: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&2;}
57028 57011 BUILD_FREETYPE=no
57029 57012 fi
57030 57013 # ..and contain a vc2010 project file
57031 57014 vcxproj_path="$FREETYPE_SRC_PATH/builds/windows/vc2010/freetype.vcxproj"
57032 57015 if test "x$BUILD_FREETYPE" = xyes && ! test -s $vcxproj_path; then
57033 57016 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&5
57034 57017 $as_echo "$as_me: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&2;}
57035 57018 BUILD_FREETYPE=no
57036 57019 fi
57037 57020 # Now check if configure found a version of 'msbuild.exe'
57038 57021 if test "x$BUILD_FREETYPE" = xyes && test "x$MSBUILD" == x ; then
57039 57022 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&5
57040 57023 $as_echo "$as_me: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&2;}
57041 57024 BUILD_FREETYPE=no
57042 57025 fi
57043 57026
57044 57027 # Ready to go..
57045 57028 if test "x$BUILD_FREETYPE" = xyes; then
57046 57029 # msbuild requires trailing slashes for output directories
57047 57030 freetype_lib_path="$FREETYPE_SRC_PATH/lib$OPENJDK_TARGET_CPU_BITS/"
57048 57031 freetype_lib_path_unix="$freetype_lib_path"
57049 57032 freetype_obj_path="$FREETYPE_SRC_PATH/obj$OPENJDK_TARGET_CPU_BITS/"
57050 57033
57051 57034 unix_path="$vcxproj_path"
57052 57035 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57053 57036 windows_path=`$CYGPATH -m "$unix_path"`
57054 57037 vcxproj_path="$windows_path"
57055 57038 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57056 57039 windows_path=`cmd //c echo $unix_path`
57057 57040 vcxproj_path="$windows_path"
57058 57041 fi
57059 57042
57060 57043
57061 57044 unix_path="$freetype_lib_path"
57062 57045 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57063 57046 windows_path=`$CYGPATH -m "$unix_path"`
57064 57047 freetype_lib_path="$windows_path"
57065 57048 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57066 57049 windows_path=`cmd //c echo $unix_path`
57067 57050 freetype_lib_path="$windows_path"
57068 57051 fi
57069 57052
57070 57053
57071 57054 unix_path="$freetype_obj_path"
57072 57055 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57073 57056 windows_path=`$CYGPATH -m "$unix_path"`
57074 57057 freetype_obj_path="$windows_path"
57075 57058 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57076 57059 windows_path=`cmd //c echo $unix_path`
57077 57060 freetype_obj_path="$windows_path"
57078 57061 fi
57079 57062
57080 57063 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
57081 57064 freetype_platform=x64
57082 57065 else
57083 57066 freetype_platform=win32
57084 57067 fi
57085 57068
57086 57069 # The original freetype project file is for VS 2010 (i.e. 'v100'),
57087 57070 # so we have to adapt the toolset if building with any other toolsed (i.e. SDK).
57088 57071 # Currently 'PLATFORM_TOOLSET' is set in 'TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT'/
57089 57072 # 'TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT' in toolchain_windows.m4
57090 57073 { $as_echo "$as_me:${as_lineno-$LINENO}: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&5
57091 57074 $as_echo "$as_me: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&6;}
57092 57075
57093 57076 # First we try to build the freetype.dll
57094 57077 $ECHO -e "@echo off\n"\
57095 57078 "$MSBUILD $vcxproj_path "\
57096 57079 "/p:PlatformToolset=$PLATFORM_TOOLSET "\
57097 57080 "/p:Configuration=\"Release Multithreaded\" "\
57098 57081 "/p:Platform=$freetype_platform "\
57099 57082 "/p:ConfigurationType=DynamicLibrary "\
57100 57083 "/p:TargetName=freetype "\
57101 57084 "/p:OutDir=\"$freetype_lib_path\" "\
57102 57085 "/p:IntDir=\"$freetype_obj_path\" > freetype.log" > freetype.bat
57103 57086 cmd /c freetype.bat
57104 57087
57105 57088 if test -s "$freetype_lib_path_unix/freetype.dll"; then
57106 57089 # If that succeeds we also build freetype.lib
57107 57090 $ECHO -e "@echo off\n"\
57108 57091 "$MSBUILD $vcxproj_path "\
57109 57092 "/p:PlatformToolset=$PLATFORM_TOOLSET "\
57110 57093 "/p:Configuration=\"Release Multithreaded\" "\
57111 57094 "/p:Platform=$freetype_platform "\
57112 57095 "/p:ConfigurationType=StaticLibrary "\
57113 57096 "/p:TargetName=freetype "\
57114 57097 "/p:OutDir=\"$freetype_lib_path\" "\
57115 57098 "/p:IntDir=\"$freetype_obj_path\" >> freetype.log" > freetype.bat
57116 57099 cmd /c freetype.bat
57117 57100
57118 57101 if test -s "$freetype_lib_path_unix/freetype.lib"; then
57119 57102 # Once we build both, lib and dll, set freetype lib and include path appropriately
57120 57103 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_SRC_PATH/include"
57121 57104 POTENTIAL_FREETYPE_LIB_PATH="$freetype_lib_path_unix"
57122 57105 { $as_echo "$as_me:${as_lineno-$LINENO}: Compiling freetype sources succeeded! (see freetype.log for build results)" >&5
57123 57106 $as_echo "$as_me: Compiling freetype sources succeeded! (see freetype.log for build results)" >&6;}
57124 57107 else
57125 57108 BUILD_FREETYPE=no
57126 57109 fi
57127 57110 else
57128 57111 BUILD_FREETYPE=no
57129 57112 fi
57130 57113 fi
57131 57114
57132 57115 if test "x$BUILD_FREETYPE" = xyes; then
57133 57116 # Okay, we built it. Check that it works.
57134 57117
57135 57118 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57136 57119 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
57137 57120 METHOD="--with-freetype-src"
57138 57121
57139 57122 # Let's start with an optimistic view of the world :-)
57140 57123 FOUND_FREETYPE=yes
57141 57124
57142 57125 # First look for the canonical freetype main include file ft2build.h.
57143 57126 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57144 57127 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
57145 57128 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
57146 57129 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57147 57130 # Fail.
57148 57131 FOUND_FREETYPE=no
57149 57132 fi
57150 57133 fi
57151 57134
57152 57135 if test "x$FOUND_FREETYPE" = xyes; then
57153 57136 # Include file found, let's continue the sanity check.
57154 57137 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
57155 57138 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
57156 57139
57157 57140 # Reset to default value
57158 57141 FREETYPE_BASE_NAME=freetype
57159 57142 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
57160 57143 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
57161 57144 if test "x$OPENJDK_TARGET_OS" = xmacosx \
57162 57145 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
57163 57146 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
57164 57147 # for the .6 version explicitly.
57165 57148 FREETYPE_BASE_NAME=freetype.6
57166 57149 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
57167 57150 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
57168 57151 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
57169 57152 else
57170 57153 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
57171 57154 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
57172 57155 FOUND_FREETYPE=no
57173 57156 fi
57174 57157 else
57175 57158 if test "x$OPENJDK_TARGET_OS" = xwindows; then
57176 57159 # On Windows, we will need both .lib and .dll file.
57177 57160 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
57178 57161 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
57179 57162 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
57180 57163 FOUND_FREETYPE=no
57181 57164 fi
57182 57165 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
57183 57166 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
57184 57167 # Found lib in isa dir, use that instead.
57185 57168 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
57186 57169 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
57187 57170 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
57188 57171 fi
57189 57172 fi
57190 57173 fi
57191 57174
57192 57175 if test "x$FOUND_FREETYPE" = xyes; then
57193 57176
57194 57177 # Only process if variable expands to non-empty
57195 57178
57196 57179 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
57197 57180 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57198 57181
57199 57182 # Input might be given as Windows format, start by converting to
57200 57183 # unix format.
57201 57184 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57202 57185 new_path=`$CYGPATH -u "$path"`
57203 57186
57204 57187 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
57205 57188 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
57206 57189 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
57207 57190 # "foo.exe" is OK but "foo" is an error.
57208 57191 #
57209 57192 # This test is therefore slightly more accurate than "test -f" to check for file precense.
57210 57193 # It is also a way to make sure we got the proper file name for the real test later on.
57211 57194 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
57212 57195 if test "x$test_shortpath" = x; then
57213 57196 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
57214 57197 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
57215 57198 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
57216 57199 fi
57217 57200
57218 57201 # Call helper function which possibly converts this using DOS-style short mode.
57219 57202 # If so, the updated path is stored in $new_path.
57220 57203
57221 57204 input_path="$new_path"
57222 57205 # Check if we need to convert this using DOS-style short mode. If the path
57223 57206 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57224 57207 # take no chances and rewrite it.
57225 57208 # Note: m4 eats our [], so we need to use [ and ] instead.
57226 57209 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
57227 57210 if test "x$has_forbidden_chars" != x; then
57228 57211 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57229 57212 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
57230 57213 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
57231 57214 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
57232 57215 # Going to short mode and back again did indeed matter. Since short mode is
57233 57216 # case insensitive, let's make it lowercase to improve readability.
57234 57217 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57235 57218 # Now convert it back to Unix-style (cygpath)
57236 57219 input_path=`$CYGPATH -u "$shortmode_path"`
57237 57220 new_path="$input_path"
57238 57221 fi
57239 57222 fi
57240 57223
57241 57224 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
57242 57225 if test "x$test_cygdrive_prefix" = x; then
57243 57226 # As a simple fix, exclude /usr/bin since it's not a real path.
57244 57227 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
57245 57228 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
57246 57229 # a path prefixed by /cygdrive for fixpath to work.
57247 57230 new_path="$CYGWIN_ROOT_PATH$input_path"
57248 57231 fi
57249 57232 fi
57250 57233
57251 57234
57252 57235 if test "x$path" != "x$new_path"; then
57253 57236 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
57254 57237 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
57255 57238 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
57256 57239 fi
57257 57240
57258 57241 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57259 57242
57260 57243 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57261 57244 has_colon=`$ECHO $path | $GREP ^.:`
57262 57245 new_path="$path"
57263 57246 if test "x$has_colon" = x; then
57264 57247 # Not in mixed or Windows style, start by that.
57265 57248 new_path=`cmd //c echo $path`
57266 57249 fi
57267 57250
57268 57251
57269 57252 input_path="$new_path"
57270 57253 # Check if we need to convert this using DOS-style short mode. If the path
57271 57254 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57272 57255 # take no chances and rewrite it.
57273 57256 # Note: m4 eats our [], so we need to use [ and ] instead.
57274 57257 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
57275 57258 if test "x$has_forbidden_chars" != x; then
57276 57259 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57277 57260 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57278 57261 fi
57279 57262
57280 57263
57281 57264 windows_path="$new_path"
57282 57265 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57283 57266 unix_path=`$CYGPATH -u "$windows_path"`
57284 57267 new_path="$unix_path"
57285 57268 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57286 57269 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
57287 57270 new_path="$unix_path"
57288 57271 fi
57289 57272
57290 57273 if test "x$path" != "x$new_path"; then
57291 57274 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
57292 57275 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
57293 57276 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
57294 57277 fi
57295 57278
57296 57279 # Save the first 10 bytes of this path to the storage, so fixpath can work.
57297 57280 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
57298 57281
57299 57282 else
57300 57283 # We're on a unix platform. Hooray! :)
57301 57284 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57302 57285 has_space=`$ECHO "$path" | $GREP " "`
57303 57286 if test "x$has_space" != x; then
57304 57287 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
57305 57288 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
57306 57289 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
57307 57290 fi
57308 57291
57309 57292 # Use eval to expand a potential ~
57310 57293 eval path="$path"
57311 57294 if test ! -f "$path" && test ! -d "$path"; then
57312 57295 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
57313 57296 fi
57314 57297
57315 57298 if test -d "$path"; then
57316 57299 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
57317 57300 else
57318 57301 dir="`$DIRNAME "$path"`"
57319 57302 base="`$BASENAME "$path"`"
57320 57303 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
57321 57304 fi
57322 57305 fi
57323 57306 fi
57324 57307
57325 57308
57326 57309 # Only process if variable expands to non-empty
57327 57310
57328 57311 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
57329 57312 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57330 57313
57331 57314 # Input might be given as Windows format, start by converting to
57332 57315 # unix format.
57333 57316 path="$POTENTIAL_FREETYPE_LIB_PATH"
57334 57317 new_path=`$CYGPATH -u "$path"`
57335 57318
57336 57319 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
57337 57320 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
57338 57321 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
57339 57322 # "foo.exe" is OK but "foo" is an error.
57340 57323 #
57341 57324 # This test is therefore slightly more accurate than "test -f" to check for file precense.
57342 57325 # It is also a way to make sure we got the proper file name for the real test later on.
57343 57326 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
57344 57327 if test "x$test_shortpath" = x; then
57345 57328 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
57346 57329 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
57347 57330 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
57348 57331 fi
57349 57332
57350 57333 # Call helper function which possibly converts this using DOS-style short mode.
57351 57334 # If so, the updated path is stored in $new_path.
57352 57335
57353 57336 input_path="$new_path"
57354 57337 # Check if we need to convert this using DOS-style short mode. If the path
57355 57338 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57356 57339 # take no chances and rewrite it.
57357 57340 # Note: m4 eats our [], so we need to use [ and ] instead.
57358 57341 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
57359 57342 if test "x$has_forbidden_chars" != x; then
57360 57343 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57361 57344 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
57362 57345 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
57363 57346 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
57364 57347 # Going to short mode and back again did indeed matter. Since short mode is
57365 57348 # case insensitive, let's make it lowercase to improve readability.
57366 57349 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57367 57350 # Now convert it back to Unix-style (cygpath)
57368 57351 input_path=`$CYGPATH -u "$shortmode_path"`
57369 57352 new_path="$input_path"
57370 57353 fi
57371 57354 fi
57372 57355
57373 57356 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
57374 57357 if test "x$test_cygdrive_prefix" = x; then
57375 57358 # As a simple fix, exclude /usr/bin since it's not a real path.
57376 57359 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
57377 57360 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
57378 57361 # a path prefixed by /cygdrive for fixpath to work.
57379 57362 new_path="$CYGWIN_ROOT_PATH$input_path"
57380 57363 fi
57381 57364 fi
57382 57365
57383 57366
57384 57367 if test "x$path" != "x$new_path"; then
57385 57368 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
57386 57369 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
57387 57370 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
57388 57371 fi
57389 57372
57390 57373 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57391 57374
57392 57375 path="$POTENTIAL_FREETYPE_LIB_PATH"
57393 57376 has_colon=`$ECHO $path | $GREP ^.:`
57394 57377 new_path="$path"
57395 57378 if test "x$has_colon" = x; then
57396 57379 # Not in mixed or Windows style, start by that.
57397 57380 new_path=`cmd //c echo $path`
57398 57381 fi
57399 57382
57400 57383
57401 57384 input_path="$new_path"
57402 57385 # Check if we need to convert this using DOS-style short mode. If the path
57403 57386 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57404 57387 # take no chances and rewrite it.
57405 57388 # Note: m4 eats our [], so we need to use [ and ] instead.
57406 57389 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
57407 57390 if test "x$has_forbidden_chars" != x; then
57408 57391 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57409 57392 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57410 57393 fi
57411 57394
57412 57395
57413 57396 windows_path="$new_path"
57414 57397 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57415 57398 unix_path=`$CYGPATH -u "$windows_path"`
57416 57399 new_path="$unix_path"
57417 57400 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57418 57401 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
57419 57402 new_path="$unix_path"
57420 57403 fi
57421 57404
57422 57405 if test "x$path" != "x$new_path"; then
57423 57406 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
57424 57407 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
57425 57408 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
57426 57409 fi
57427 57410
57428 57411 # Save the first 10 bytes of this path to the storage, so fixpath can work.
57429 57412 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
57430 57413
57431 57414 else
57432 57415 # We're on a unix platform. Hooray! :)
57433 57416 path="$POTENTIAL_FREETYPE_LIB_PATH"
57434 57417 has_space=`$ECHO "$path" | $GREP " "`
57435 57418 if test "x$has_space" != x; then
57436 57419 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
57437 57420 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
57438 57421 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
57439 57422 fi
57440 57423
57441 57424 # Use eval to expand a potential ~
57442 57425 eval path="$path"
57443 57426 if test ! -f "$path" && test ! -d "$path"; then
57444 57427 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
57445 57428 fi
57446 57429
57447 57430 if test -d "$path"; then
57448 57431 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
57449 57432 else
57450 57433 dir="`$DIRNAME "$path"`"
57451 57434 base="`$BASENAME "$path"`"
57452 57435 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
57453 57436 fi
57454 57437 fi
57455 57438 fi
57456 57439
57457 57440
57458 57441 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57459 57442 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
57460 57443 $as_echo_n "checking for freetype includes... " >&6; }
57461 57444 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
57462 57445 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
57463 57446 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
57464 57447 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
57465 57448 $as_echo_n "checking for freetype libraries... " >&6; }
57466 57449 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
57467 57450 $as_echo "$FREETYPE_LIB_PATH" >&6; }
57468 57451 fi
57469 57452
57470 57453 if test "x$FOUND_FREETYPE" != xyes; then
57471 57454 as_fn_error $? "Can not use the built freetype at location given by --with-freetype-src" "$LINENO" 5
57472 57455 fi
57473 57456 else
57474 57457 { $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-src but building freetype failed. (see freetype.log for build results)" >&5
57475 57458 $as_echo "$as_me: User specified --with-freetype-src but building freetype failed. (see freetype.log for build results)" >&6;}
57476 57459 as_fn_error $? "Consider building freetype manually and using --with-freetype instead." "$LINENO" 5
57477 57460 fi
57478 57461 else
57479 57462 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src is currently only supported on Windows - ignoring" >&5
57480 57463 $as_echo "$as_me: WARNING: --with-freetype-src is currently only supported on Windows - ignoring" >&2;}
57481 57464 fi
57482 57465 fi
57483 57466
57484 57467 if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then
57485 57468 # User has specified settings
57486 57469
57487 57470 if test "x$BUNDLE_FREETYPE" = x; then
57488 57471 # If not specified, default is to bundle freetype
57489 57472 BUNDLE_FREETYPE=yes
57490 57473 fi
57491 57474
57492 57475 if test "x$with_freetype" != x; then
57493 57476 POTENTIAL_FREETYPE_INCLUDE_PATH="$with_freetype/include"
57494 57477 POTENTIAL_FREETYPE_LIB_PATH="$with_freetype/lib"
57495 57478 fi
57496 57479
57497 57480 # Allow --with-freetype-lib and --with-freetype-include to override
57498 57481 if test "x$with_freetype_include" != x; then
57499 57482 POTENTIAL_FREETYPE_INCLUDE_PATH="$with_freetype_include"
57500 57483 fi
57501 57484 if test "x$with_freetype_lib" != x; then
57502 57485 POTENTIAL_FREETYPE_LIB_PATH="$with_freetype_lib"
57503 57486 fi
57504 57487
57505 57488 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x && test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
57506 57489 # Okay, we got it. Check that it works.
57507 57490
57508 57491 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57509 57492 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
57510 57493 METHOD="--with-freetype"
57511 57494
57512 57495 # Let's start with an optimistic view of the world :-)
57513 57496 FOUND_FREETYPE=yes
57514 57497
57515 57498 # First look for the canonical freetype main include file ft2build.h.
57516 57499 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57517 57500 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
57518 57501 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
57519 57502 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57520 57503 # Fail.
57521 57504 FOUND_FREETYPE=no
57522 57505 fi
57523 57506 fi
57524 57507
57525 57508 if test "x$FOUND_FREETYPE" = xyes; then
57526 57509 # Include file found, let's continue the sanity check.
57527 57510 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
57528 57511 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
57529 57512
57530 57513 # Reset to default value
57531 57514 FREETYPE_BASE_NAME=freetype
57532 57515 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
57533 57516 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
57534 57517 if test "x$OPENJDK_TARGET_OS" = xmacosx \
57535 57518 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
57536 57519 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
57537 57520 # for the .6 version explicitly.
57538 57521 FREETYPE_BASE_NAME=freetype.6
57539 57522 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
57540 57523 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
57541 57524 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
57542 57525 else
57543 57526 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
57544 57527 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
57545 57528 FOUND_FREETYPE=no
57546 57529 fi
57547 57530 else
57548 57531 if test "x$OPENJDK_TARGET_OS" = xwindows; then
57549 57532 # On Windows, we will need both .lib and .dll file.
57550 57533 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
57551 57534 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
57552 57535 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
57553 57536 FOUND_FREETYPE=no
57554 57537 fi
57555 57538 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
57556 57539 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
57557 57540 # Found lib in isa dir, use that instead.
57558 57541 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
57559 57542 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
57560 57543 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
57561 57544 fi
57562 57545 fi
57563 57546 fi
57564 57547
57565 57548 if test "x$FOUND_FREETYPE" = xyes; then
57566 57549
57567 57550 # Only process if variable expands to non-empty
57568 57551
57569 57552 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
57570 57553 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57571 57554
57572 57555 # Input might be given as Windows format, start by converting to
57573 57556 # unix format.
57574 57557 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57575 57558 new_path=`$CYGPATH -u "$path"`
57576 57559
57577 57560 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
57578 57561 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
57579 57562 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
57580 57563 # "foo.exe" is OK but "foo" is an error.
57581 57564 #
57582 57565 # This test is therefore slightly more accurate than "test -f" to check for file precense.
57583 57566 # It is also a way to make sure we got the proper file name for the real test later on.
57584 57567 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
57585 57568 if test "x$test_shortpath" = x; then
57586 57569 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
57587 57570 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
57588 57571 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
57589 57572 fi
57590 57573
57591 57574 # Call helper function which possibly converts this using DOS-style short mode.
57592 57575 # If so, the updated path is stored in $new_path.
57593 57576
57594 57577 input_path="$new_path"
57595 57578 # Check if we need to convert this using DOS-style short mode. If the path
57596 57579 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57597 57580 # take no chances and rewrite it.
57598 57581 # Note: m4 eats our [], so we need to use [ and ] instead.
57599 57582 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
57600 57583 if test "x$has_forbidden_chars" != x; then
57601 57584 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57602 57585 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
57603 57586 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
57604 57587 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
57605 57588 # Going to short mode and back again did indeed matter. Since short mode is
57606 57589 # case insensitive, let's make it lowercase to improve readability.
57607 57590 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57608 57591 # Now convert it back to Unix-style (cygpath)
57609 57592 input_path=`$CYGPATH -u "$shortmode_path"`
57610 57593 new_path="$input_path"
57611 57594 fi
57612 57595 fi
57613 57596
57614 57597 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
57615 57598 if test "x$test_cygdrive_prefix" = x; then
57616 57599 # As a simple fix, exclude /usr/bin since it's not a real path.
57617 57600 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
57618 57601 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
57619 57602 # a path prefixed by /cygdrive for fixpath to work.
57620 57603 new_path="$CYGWIN_ROOT_PATH$input_path"
57621 57604 fi
57622 57605 fi
57623 57606
57624 57607
57625 57608 if test "x$path" != "x$new_path"; then
57626 57609 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
57627 57610 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
57628 57611 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
57629 57612 fi
57630 57613
57631 57614 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57632 57615
57633 57616 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57634 57617 has_colon=`$ECHO $path | $GREP ^.:`
57635 57618 new_path="$path"
57636 57619 if test "x$has_colon" = x; then
57637 57620 # Not in mixed or Windows style, start by that.
57638 57621 new_path=`cmd //c echo $path`
57639 57622 fi
57640 57623
57641 57624
57642 57625 input_path="$new_path"
57643 57626 # Check if we need to convert this using DOS-style short mode. If the path
57644 57627 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57645 57628 # take no chances and rewrite it.
57646 57629 # Note: m4 eats our [], so we need to use [ and ] instead.
57647 57630 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
57648 57631 if test "x$has_forbidden_chars" != x; then
57649 57632 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57650 57633 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57651 57634 fi
57652 57635
57653 57636
57654 57637 windows_path="$new_path"
57655 57638 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57656 57639 unix_path=`$CYGPATH -u "$windows_path"`
57657 57640 new_path="$unix_path"
57658 57641 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57659 57642 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
57660 57643 new_path="$unix_path"
57661 57644 fi
57662 57645
57663 57646 if test "x$path" != "x$new_path"; then
57664 57647 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
57665 57648 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
57666 57649 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
57667 57650 fi
57668 57651
57669 57652 # Save the first 10 bytes of this path to the storage, so fixpath can work.
57670 57653 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
57671 57654
57672 57655 else
57673 57656 # We're on a unix platform. Hooray! :)
57674 57657 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57675 57658 has_space=`$ECHO "$path" | $GREP " "`
57676 57659 if test "x$has_space" != x; then
57677 57660 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
57678 57661 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
57679 57662 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
57680 57663 fi
57681 57664
57682 57665 # Use eval to expand a potential ~
57683 57666 eval path="$path"
57684 57667 if test ! -f "$path" && test ! -d "$path"; then
57685 57668 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
57686 57669 fi
57687 57670
57688 57671 if test -d "$path"; then
57689 57672 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
57690 57673 else
57691 57674 dir="`$DIRNAME "$path"`"
57692 57675 base="`$BASENAME "$path"`"
57693 57676 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
57694 57677 fi
57695 57678 fi
57696 57679 fi
57697 57680
57698 57681
57699 57682 # Only process if variable expands to non-empty
57700 57683
57701 57684 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
57702 57685 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57703 57686
57704 57687 # Input might be given as Windows format, start by converting to
57705 57688 # unix format.
57706 57689 path="$POTENTIAL_FREETYPE_LIB_PATH"
57707 57690 new_path=`$CYGPATH -u "$path"`
57708 57691
57709 57692 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
57710 57693 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
57711 57694 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
57712 57695 # "foo.exe" is OK but "foo" is an error.
57713 57696 #
57714 57697 # This test is therefore slightly more accurate than "test -f" to check for file precense.
57715 57698 # It is also a way to make sure we got the proper file name for the real test later on.
57716 57699 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
57717 57700 if test "x$test_shortpath" = x; then
57718 57701 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
57719 57702 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
57720 57703 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
57721 57704 fi
57722 57705
57723 57706 # Call helper function which possibly converts this using DOS-style short mode.
57724 57707 # If so, the updated path is stored in $new_path.
57725 57708
57726 57709 input_path="$new_path"
57727 57710 # Check if we need to convert this using DOS-style short mode. If the path
57728 57711 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57729 57712 # take no chances and rewrite it.
57730 57713 # Note: m4 eats our [], so we need to use [ and ] instead.
57731 57714 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
57732 57715 if test "x$has_forbidden_chars" != x; then
57733 57716 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57734 57717 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
57735 57718 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
57736 57719 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
57737 57720 # Going to short mode and back again did indeed matter. Since short mode is
57738 57721 # case insensitive, let's make it lowercase to improve readability.
57739 57722 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57740 57723 # Now convert it back to Unix-style (cygpath)
57741 57724 input_path=`$CYGPATH -u "$shortmode_path"`
57742 57725 new_path="$input_path"
57743 57726 fi
57744 57727 fi
57745 57728
57746 57729 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
57747 57730 if test "x$test_cygdrive_prefix" = x; then
57748 57731 # As a simple fix, exclude /usr/bin since it's not a real path.
57749 57732 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
57750 57733 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
57751 57734 # a path prefixed by /cygdrive for fixpath to work.
57752 57735 new_path="$CYGWIN_ROOT_PATH$input_path"
57753 57736 fi
57754 57737 fi
57755 57738
57756 57739
57757 57740 if test "x$path" != "x$new_path"; then
57758 57741 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
57759 57742 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
57760 57743 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
57761 57744 fi
57762 57745
57763 57746 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57764 57747
57765 57748 path="$POTENTIAL_FREETYPE_LIB_PATH"
57766 57749 has_colon=`$ECHO $path | $GREP ^.:`
57767 57750 new_path="$path"
57768 57751 if test "x$has_colon" = x; then
57769 57752 # Not in mixed or Windows style, start by that.
57770 57753 new_path=`cmd //c echo $path`
57771 57754 fi
57772 57755
57773 57756
57774 57757 input_path="$new_path"
57775 57758 # Check if we need to convert this using DOS-style short mode. If the path
57776 57759 # contains just simple characters, use it. Otherwise (spaces, weird characters),
57777 57760 # take no chances and rewrite it.
57778 57761 # Note: m4 eats our [], so we need to use [ and ] instead.
57779 57762 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
57780 57763 if test "x$has_forbidden_chars" != x; then
57781 57764 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
57782 57765 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
57783 57766 fi
57784 57767
57785 57768
57786 57769 windows_path="$new_path"
57787 57770 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57788 57771 unix_path=`$CYGPATH -u "$windows_path"`
57789 57772 new_path="$unix_path"
57790 57773 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57791 57774 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
57792 57775 new_path="$unix_path"
57793 57776 fi
57794 57777
57795 57778 if test "x$path" != "x$new_path"; then
57796 57779 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
57797 57780 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
57798 57781 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
57799 57782 fi
57800 57783
57801 57784 # Save the first 10 bytes of this path to the storage, so fixpath can work.
57802 57785 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
57803 57786
57804 57787 else
57805 57788 # We're on a unix platform. Hooray! :)
57806 57789 path="$POTENTIAL_FREETYPE_LIB_PATH"
57807 57790 has_space=`$ECHO "$path" | $GREP " "`
57808 57791 if test "x$has_space" != x; then
57809 57792 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
57810 57793 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
57811 57794 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
57812 57795 fi
57813 57796
57814 57797 # Use eval to expand a potential ~
57815 57798 eval path="$path"
57816 57799 if test ! -f "$path" && test ! -d "$path"; then
57817 57800 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
57818 57801 fi
57819 57802
57820 57803 if test -d "$path"; then
57821 57804 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
57822 57805 else
57823 57806 dir="`$DIRNAME "$path"`"
57824 57807 base="`$BASENAME "$path"`"
57825 57808 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
57826 57809 fi
57827 57810 fi
57828 57811 fi
57829 57812
57830 57813
57831 57814 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
57832 57815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
57833 57816 $as_echo_n "checking for freetype includes... " >&6; }
57834 57817 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
57835 57818 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
57836 57819 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
57837 57820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
57838 57821 $as_echo_n "checking for freetype libraries... " >&6; }
57839 57822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
57840 57823 $as_echo "$FREETYPE_LIB_PATH" >&6; }
57841 57824 fi
57842 57825
57843 57826 if test "x$FOUND_FREETYPE" != xyes; then
57844 57827 as_fn_error $? "Can not find or use freetype at location given by --with-freetype" "$LINENO" 5
57845 57828 fi
57846 57829 else
57847 57830 # User specified only one of lib or include. This is an error.
57848 57831 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" = x ; then
57849 57832 { $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-lib but not --with-freetype-include" >&5
57850 57833 $as_echo "$as_me: User specified --with-freetype-lib but not --with-freetype-include" >&6;}
57851 57834 as_fn_error $? "Need both freetype lib and include paths. Consider using --with-freetype instead." "$LINENO" 5
57852 57835 else
57853 57836 { $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-include but not --with-freetype-lib" >&5
57854 57837 $as_echo "$as_me: User specified --with-freetype-include but not --with-freetype-lib" >&6;}
57855 57838 as_fn_error $? "Need both freetype lib and include paths. Consider using --with-freetype instead." "$LINENO" 5
57856 57839 fi
57857 57840 fi
57858 57841 else
57859 57842 # User did not specify settings, but we need freetype. Try to locate it.
57860 57843
57861 57844 if test "x$BUNDLE_FREETYPE" = x; then
57862 57845 # If not specified, default is to bundle freetype only on windows
57863 57846 if test "x$OPENJDK_TARGET_OS" = xwindows; then
57864 57847 BUNDLE_FREETYPE=yes
57865 57848 else
57866 57849 BUNDLE_FREETYPE=no
57867 57850 fi
57868 57851 fi
57869 57852
57870 57853 # If we have a sysroot, assume that's where we are supposed to look and skip pkg-config.
57871 57854 if test "x$SYSROOT" = x; then
57872 57855 if test "x$FOUND_FREETYPE" != xyes; then
57873 57856 # Check modules using pkg-config, but only if we have it (ugly output results otherwise)
57874 57857 if test "x$PKG_CONFIG" != x; then
57875 57858
57876 57859 pkg_failed=no
57877 57860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
57878 57861 $as_echo_n "checking for FREETYPE... " >&6; }
57879 57862
57880 57863 if test -n "$FREETYPE_CFLAGS"; then
57881 57864 pkg_cv_FREETYPE_CFLAGS="$FREETYPE_CFLAGS"
57882 57865 elif test -n "$PKG_CONFIG"; then
57883 57866 if test -n "$PKG_CONFIG" && \
57884 57867 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
57885 57868 ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
57886 57869 ac_status=$?
57887 57870 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
57888 57871 test $ac_status = 0; }; then
57889 57872 pkg_cv_FREETYPE_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null`
57890 57873 else
57891 57874 pkg_failed=yes
57892 57875 fi
57893 57876 else
57894 57877 pkg_failed=untried
57895 57878 fi
57896 57879 if test -n "$FREETYPE_LIBS"; then
57897 57880 pkg_cv_FREETYPE_LIBS="$FREETYPE_LIBS"
57898 57881 elif test -n "$PKG_CONFIG"; then
57899 57882 if test -n "$PKG_CONFIG" && \
57900 57883 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
57901 57884 ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
57902 57885 ac_status=$?
57903 57886 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
57904 57887 test $ac_status = 0; }; then
57905 57888 pkg_cv_FREETYPE_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null`
57906 57889 else
57907 57890 pkg_failed=yes
57908 57891 fi
57909 57892 else
57910 57893 pkg_failed=untried
57911 57894 fi
57912 57895
57913 57896
57914 57897
57915 57898 if test $pkg_failed = yes; then
57916 57899
57917 57900 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
57918 57901 _pkg_short_errors_supported=yes
57919 57902 else
57920 57903 _pkg_short_errors_supported=no
57921 57904 fi
57922 57905 if test $_pkg_short_errors_supported = yes; then
57923 57906 FREETYPE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "freetype2" 2>&1`
57924 57907 else
57925 57908 FREETYPE_PKG_ERRORS=`$PKG_CONFIG --print-errors "freetype2" 2>&1`
57926 57909 fi
57927 57910 # Put the nasty error message in config.log where it belongs
57928 57911 echo "$FREETYPE_PKG_ERRORS" >&5
57929 57912
57930 57913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
57931 57914 $as_echo "no" >&6; }
57932 57915 FOUND_FREETYPE=no
57933 57916 elif test $pkg_failed = untried; then
57934 57917 FOUND_FREETYPE=no
57935 57918 else
57936 57919 FREETYPE_CFLAGS=$pkg_cv_FREETYPE_CFLAGS
57937 57920 FREETYPE_LIBS=$pkg_cv_FREETYPE_LIBS
57938 57921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
57939 57922 $as_echo "yes" >&6; }
57940 57923 FOUND_FREETYPE=yes
57941 57924 fi
57942 57925 if test "x$FOUND_FREETYPE" = xyes; then
57943 57926 # On solaris, pkg_check adds -lz to freetype libs, which isn't necessary for us.
57944 57927 FREETYPE_LIBS=`$ECHO $FREETYPE_LIBS | $SED 's/-lz//g'`
57945 57928 # 64-bit libs for Solaris x86 are installed in the amd64 subdirectory, change lib to lib/amd64
57946 57929 if test "x$OPENJDK_TARGET_OS" = xsolaris && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
57947 57930 FREETYPE_LIBS=`$ECHO $FREETYPE_LIBS | $SED 's?/lib?/lib/amd64?g'`
57948 57931 fi
57949 57932 # PKG_CHECK_MODULES will set FREETYPE_CFLAGS and _LIBS, but we don't get a lib path for bundling.
57950 57933 if test "x$BUNDLE_FREETYPE" = xyes; then
57951 57934 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype using pkg-config, but ignoring since we can not bundle that" >&5
57952 57935 $as_echo "$as_me: Found freetype using pkg-config, but ignoring since we can not bundle that" >&6;}
57953 57936 FOUND_FREETYPE=no
57954 57937 else
57955 57938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
57956 57939 $as_echo_n "checking for freetype... " >&6; }
57957 57940 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
57958 57941 $as_echo "yes (using pkg-config)" >&6; }
57959 57942 fi
57960 57943 fi
57961 57944 fi
57962 57945 fi
57963 57946 fi
57964 57947
57965 57948 if test "x$FOUND_FREETYPE" != xyes; then
57966 57949 # Check in well-known locations
57967 57950 if test "x$OPENJDK_TARGET_OS" = xwindows; then
57968 57951 FREETYPE_BASE_DIR="$PROGRAMFILES/GnuWin32"
57969 57952
57970 57953 windows_path="$FREETYPE_BASE_DIR"
57971 57954 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
57972 57955 unix_path=`$CYGPATH -u "$windows_path"`
57973 57956 FREETYPE_BASE_DIR="$unix_path"
57974 57957 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
57975 57958 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
57976 57959 FREETYPE_BASE_DIR="$unix_path"
57977 57960 fi
57978 57961
57979 57962
57980 57963 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
57981 57964 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
57982 57965 METHOD="well-known location"
57983 57966
57984 57967 # Let's start with an optimistic view of the world :-)
57985 57968 FOUND_FREETYPE=yes
57986 57969
57987 57970 # First look for the canonical freetype main include file ft2build.h.
57988 57971 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57989 57972 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
57990 57973 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
57991 57974 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
57992 57975 # Fail.
57993 57976 FOUND_FREETYPE=no
57994 57977 fi
57995 57978 fi
57996 57979
57997 57980 if test "x$FOUND_FREETYPE" = xyes; then
57998 57981 # Include file found, let's continue the sanity check.
57999 57982 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
58000 57983 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
58001 57984
58002 57985 # Reset to default value
58003 57986 FREETYPE_BASE_NAME=freetype
58004 57987 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58005 57988 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
58006 57989 if test "x$OPENJDK_TARGET_OS" = xmacosx \
58007 57990 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
58008 57991 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
58009 57992 # for the .6 version explicitly.
58010 57993 FREETYPE_BASE_NAME=freetype.6
58011 57994 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58012 57995 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
58013 57996 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
58014 57997 else
58015 57998 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
58016 57999 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
58017 58000 FOUND_FREETYPE=no
58018 58001 fi
58019 58002 else
58020 58003 if test "x$OPENJDK_TARGET_OS" = xwindows; then
58021 58004 # On Windows, we will need both .lib and .dll file.
58022 58005 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
58023 58006 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
58024 58007 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
58025 58008 FOUND_FREETYPE=no
58026 58009 fi
58027 58010 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
58028 58011 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
58029 58012 # Found lib in isa dir, use that instead.
58030 58013 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
58031 58014 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
58032 58015 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
58033 58016 fi
58034 58017 fi
58035 58018 fi
58036 58019
58037 58020 if test "x$FOUND_FREETYPE" = xyes; then
58038 58021
58039 58022 # Only process if variable expands to non-empty
58040 58023
58041 58024 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
58042 58025 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58043 58026
58044 58027 # Input might be given as Windows format, start by converting to
58045 58028 # unix format.
58046 58029 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58047 58030 new_path=`$CYGPATH -u "$path"`
58048 58031
58049 58032 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58050 58033 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58051 58034 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58052 58035 # "foo.exe" is OK but "foo" is an error.
58053 58036 #
58054 58037 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58055 58038 # It is also a way to make sure we got the proper file name for the real test later on.
58056 58039 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58057 58040 if test "x$test_shortpath" = x; then
58058 58041 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58059 58042 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58060 58043 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
58061 58044 fi
58062 58045
58063 58046 # Call helper function which possibly converts this using DOS-style short mode.
58064 58047 # If so, the updated path is stored in $new_path.
58065 58048
58066 58049 input_path="$new_path"
58067 58050 # Check if we need to convert this using DOS-style short mode. If the path
58068 58051 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58069 58052 # take no chances and rewrite it.
58070 58053 # Note: m4 eats our [], so we need to use [ and ] instead.
58071 58054 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58072 58055 if test "x$has_forbidden_chars" != x; then
58073 58056 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58074 58057 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58075 58058 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58076 58059 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58077 58060 # Going to short mode and back again did indeed matter. Since short mode is
58078 58061 # case insensitive, let's make it lowercase to improve readability.
58079 58062 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58080 58063 # Now convert it back to Unix-style (cygpath)
58081 58064 input_path=`$CYGPATH -u "$shortmode_path"`
58082 58065 new_path="$input_path"
58083 58066 fi
58084 58067 fi
58085 58068
58086 58069 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58087 58070 if test "x$test_cygdrive_prefix" = x; then
58088 58071 # As a simple fix, exclude /usr/bin since it's not a real path.
58089 58072 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58090 58073 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58091 58074 # a path prefixed by /cygdrive for fixpath to work.
58092 58075 new_path="$CYGWIN_ROOT_PATH$input_path"
58093 58076 fi
58094 58077 fi
58095 58078
58096 58079
58097 58080 if test "x$path" != "x$new_path"; then
58098 58081 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58099 58082 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58100 58083 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58101 58084 fi
58102 58085
58103 58086 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58104 58087
58105 58088 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58106 58089 has_colon=`$ECHO $path | $GREP ^.:`
58107 58090 new_path="$path"
58108 58091 if test "x$has_colon" = x; then
58109 58092 # Not in mixed or Windows style, start by that.
58110 58093 new_path=`cmd //c echo $path`
58111 58094 fi
58112 58095
58113 58096
58114 58097 input_path="$new_path"
58115 58098 # Check if we need to convert this using DOS-style short mode. If the path
58116 58099 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58117 58100 # take no chances and rewrite it.
58118 58101 # Note: m4 eats our [], so we need to use [ and ] instead.
58119 58102 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58120 58103 if test "x$has_forbidden_chars" != x; then
58121 58104 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58122 58105 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58123 58106 fi
58124 58107
58125 58108
58126 58109 windows_path="$new_path"
58127 58110 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58128 58111 unix_path=`$CYGPATH -u "$windows_path"`
58129 58112 new_path="$unix_path"
58130 58113 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58131 58114 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58132 58115 new_path="$unix_path"
58133 58116 fi
58134 58117
58135 58118 if test "x$path" != "x$new_path"; then
58136 58119 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58137 58120 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58138 58121 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58139 58122 fi
58140 58123
58141 58124 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58142 58125 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58143 58126
58144 58127 else
58145 58128 # We're on a unix platform. Hooray! :)
58146 58129 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58147 58130 has_space=`$ECHO "$path" | $GREP " "`
58148 58131 if test "x$has_space" != x; then
58149 58132 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58150 58133 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58151 58134 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58152 58135 fi
58153 58136
58154 58137 # Use eval to expand a potential ~
58155 58138 eval path="$path"
58156 58139 if test ! -f "$path" && test ! -d "$path"; then
58157 58140 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58158 58141 fi
58159 58142
58160 58143 if test -d "$path"; then
58161 58144 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
58162 58145 else
58163 58146 dir="`$DIRNAME "$path"`"
58164 58147 base="`$BASENAME "$path"`"
58165 58148 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58166 58149 fi
58167 58150 fi
58168 58151 fi
58169 58152
58170 58153
58171 58154 # Only process if variable expands to non-empty
58172 58155
58173 58156 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
58174 58157 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58175 58158
58176 58159 # Input might be given as Windows format, start by converting to
58177 58160 # unix format.
58178 58161 path="$POTENTIAL_FREETYPE_LIB_PATH"
58179 58162 new_path=`$CYGPATH -u "$path"`
58180 58163
58181 58164 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58182 58165 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58183 58166 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58184 58167 # "foo.exe" is OK but "foo" is an error.
58185 58168 #
58186 58169 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58187 58170 # It is also a way to make sure we got the proper file name for the real test later on.
58188 58171 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58189 58172 if test "x$test_shortpath" = x; then
58190 58173 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58191 58174 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58192 58175 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
58193 58176 fi
58194 58177
58195 58178 # Call helper function which possibly converts this using DOS-style short mode.
58196 58179 # If so, the updated path is stored in $new_path.
58197 58180
58198 58181 input_path="$new_path"
58199 58182 # Check if we need to convert this using DOS-style short mode. If the path
58200 58183 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58201 58184 # take no chances and rewrite it.
58202 58185 # Note: m4 eats our [], so we need to use [ and ] instead.
58203 58186 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58204 58187 if test "x$has_forbidden_chars" != x; then
58205 58188 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58206 58189 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58207 58190 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58208 58191 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58209 58192 # Going to short mode and back again did indeed matter. Since short mode is
58210 58193 # case insensitive, let's make it lowercase to improve readability.
58211 58194 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58212 58195 # Now convert it back to Unix-style (cygpath)
58213 58196 input_path=`$CYGPATH -u "$shortmode_path"`
58214 58197 new_path="$input_path"
58215 58198 fi
58216 58199 fi
58217 58200
58218 58201 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58219 58202 if test "x$test_cygdrive_prefix" = x; then
58220 58203 # As a simple fix, exclude /usr/bin since it's not a real path.
58221 58204 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58222 58205 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58223 58206 # a path prefixed by /cygdrive for fixpath to work.
58224 58207 new_path="$CYGWIN_ROOT_PATH$input_path"
58225 58208 fi
58226 58209 fi
58227 58210
58228 58211
58229 58212 if test "x$path" != "x$new_path"; then
58230 58213 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58231 58214 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58232 58215 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58233 58216 fi
58234 58217
58235 58218 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58236 58219
58237 58220 path="$POTENTIAL_FREETYPE_LIB_PATH"
58238 58221 has_colon=`$ECHO $path | $GREP ^.:`
58239 58222 new_path="$path"
58240 58223 if test "x$has_colon" = x; then
58241 58224 # Not in mixed or Windows style, start by that.
58242 58225 new_path=`cmd //c echo $path`
58243 58226 fi
58244 58227
58245 58228
58246 58229 input_path="$new_path"
58247 58230 # Check if we need to convert this using DOS-style short mode. If the path
58248 58231 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58249 58232 # take no chances and rewrite it.
58250 58233 # Note: m4 eats our [], so we need to use [ and ] instead.
58251 58234 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58252 58235 if test "x$has_forbidden_chars" != x; then
58253 58236 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58254 58237 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58255 58238 fi
58256 58239
58257 58240
58258 58241 windows_path="$new_path"
58259 58242 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58260 58243 unix_path=`$CYGPATH -u "$windows_path"`
58261 58244 new_path="$unix_path"
58262 58245 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58263 58246 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58264 58247 new_path="$unix_path"
58265 58248 fi
58266 58249
58267 58250 if test "x$path" != "x$new_path"; then
58268 58251 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58269 58252 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58270 58253 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58271 58254 fi
58272 58255
58273 58256 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58274 58257 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58275 58258
58276 58259 else
58277 58260 # We're on a unix platform. Hooray! :)
58278 58261 path="$POTENTIAL_FREETYPE_LIB_PATH"
58279 58262 has_space=`$ECHO "$path" | $GREP " "`
58280 58263 if test "x$has_space" != x; then
58281 58264 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58282 58265 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58283 58266 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58284 58267 fi
58285 58268
58286 58269 # Use eval to expand a potential ~
58287 58270 eval path="$path"
58288 58271 if test ! -f "$path" && test ! -d "$path"; then
58289 58272 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58290 58273 fi
58291 58274
58292 58275 if test -d "$path"; then
58293 58276 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
58294 58277 else
58295 58278 dir="`$DIRNAME "$path"`"
58296 58279 base="`$BASENAME "$path"`"
58297 58280 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58298 58281 fi
58299 58282 fi
58300 58283 fi
58301 58284
58302 58285
58303 58286 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58304 58287 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
58305 58288 $as_echo_n "checking for freetype includes... " >&6; }
58306 58289 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
58307 58290 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
58308 58291 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
58309 58292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
58310 58293 $as_echo_n "checking for freetype libraries... " >&6; }
58311 58294 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
58312 58295 $as_echo "$FREETYPE_LIB_PATH" >&6; }
58313 58296 fi
58314 58297
58315 58298 if test "x$FOUND_FREETYPE" != xyes; then
58316 58299 FREETYPE_BASE_DIR="$ProgramW6432/GnuWin32"
58317 58300
58318 58301 windows_path="$FREETYPE_BASE_DIR"
58319 58302 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58320 58303 unix_path=`$CYGPATH -u "$windows_path"`
58321 58304 FREETYPE_BASE_DIR="$unix_path"
58322 58305 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58323 58306 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58324 58307 FREETYPE_BASE_DIR="$unix_path"
58325 58308 fi
58326 58309
58327 58310
58328 58311 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
58329 58312 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
58330 58313 METHOD="well-known location"
58331 58314
58332 58315 # Let's start with an optimistic view of the world :-)
58333 58316 FOUND_FREETYPE=yes
58334 58317
58335 58318 # First look for the canonical freetype main include file ft2build.h.
58336 58319 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
58337 58320 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
58338 58321 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
58339 58322 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
58340 58323 # Fail.
58341 58324 FOUND_FREETYPE=no
58342 58325 fi
58343 58326 fi
58344 58327
58345 58328 if test "x$FOUND_FREETYPE" = xyes; then
58346 58329 # Include file found, let's continue the sanity check.
58347 58330 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
58348 58331 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
58349 58332
58350 58333 # Reset to default value
58351 58334 FREETYPE_BASE_NAME=freetype
58352 58335 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58353 58336 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
58354 58337 if test "x$OPENJDK_TARGET_OS" = xmacosx \
58355 58338 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
58356 58339 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
58357 58340 # for the .6 version explicitly.
58358 58341 FREETYPE_BASE_NAME=freetype.6
58359 58342 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58360 58343 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
58361 58344 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
58362 58345 else
58363 58346 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
58364 58347 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
58365 58348 FOUND_FREETYPE=no
58366 58349 fi
58367 58350 else
58368 58351 if test "x$OPENJDK_TARGET_OS" = xwindows; then
58369 58352 # On Windows, we will need both .lib and .dll file.
58370 58353 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
58371 58354 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
58372 58355 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
58373 58356 FOUND_FREETYPE=no
58374 58357 fi
58375 58358 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
58376 58359 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
58377 58360 # Found lib in isa dir, use that instead.
58378 58361 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
58379 58362 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
58380 58363 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
58381 58364 fi
58382 58365 fi
58383 58366 fi
58384 58367
58385 58368 if test "x$FOUND_FREETYPE" = xyes; then
58386 58369
58387 58370 # Only process if variable expands to non-empty
58388 58371
58389 58372 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
58390 58373 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58391 58374
58392 58375 # Input might be given as Windows format, start by converting to
58393 58376 # unix format.
58394 58377 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58395 58378 new_path=`$CYGPATH -u "$path"`
58396 58379
58397 58380 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58398 58381 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58399 58382 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58400 58383 # "foo.exe" is OK but "foo" is an error.
58401 58384 #
58402 58385 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58403 58386 # It is also a way to make sure we got the proper file name for the real test later on.
58404 58387 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58405 58388 if test "x$test_shortpath" = x; then
58406 58389 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58407 58390 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58408 58391 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
58409 58392 fi
58410 58393
58411 58394 # Call helper function which possibly converts this using DOS-style short mode.
58412 58395 # If so, the updated path is stored in $new_path.
58413 58396
58414 58397 input_path="$new_path"
58415 58398 # Check if we need to convert this using DOS-style short mode. If the path
58416 58399 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58417 58400 # take no chances and rewrite it.
58418 58401 # Note: m4 eats our [], so we need to use [ and ] instead.
58419 58402 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58420 58403 if test "x$has_forbidden_chars" != x; then
58421 58404 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58422 58405 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58423 58406 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58424 58407 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58425 58408 # Going to short mode and back again did indeed matter. Since short mode is
58426 58409 # case insensitive, let's make it lowercase to improve readability.
58427 58410 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58428 58411 # Now convert it back to Unix-style (cygpath)
58429 58412 input_path=`$CYGPATH -u "$shortmode_path"`
58430 58413 new_path="$input_path"
58431 58414 fi
58432 58415 fi
58433 58416
58434 58417 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58435 58418 if test "x$test_cygdrive_prefix" = x; then
58436 58419 # As a simple fix, exclude /usr/bin since it's not a real path.
58437 58420 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58438 58421 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58439 58422 # a path prefixed by /cygdrive for fixpath to work.
58440 58423 new_path="$CYGWIN_ROOT_PATH$input_path"
58441 58424 fi
58442 58425 fi
58443 58426
58444 58427
58445 58428 if test "x$path" != "x$new_path"; then
58446 58429 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58447 58430 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58448 58431 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58449 58432 fi
58450 58433
58451 58434 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58452 58435
58453 58436 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58454 58437 has_colon=`$ECHO $path | $GREP ^.:`
58455 58438 new_path="$path"
58456 58439 if test "x$has_colon" = x; then
58457 58440 # Not in mixed or Windows style, start by that.
58458 58441 new_path=`cmd //c echo $path`
58459 58442 fi
58460 58443
58461 58444
58462 58445 input_path="$new_path"
58463 58446 # Check if we need to convert this using DOS-style short mode. If the path
58464 58447 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58465 58448 # take no chances and rewrite it.
58466 58449 # Note: m4 eats our [], so we need to use [ and ] instead.
58467 58450 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58468 58451 if test "x$has_forbidden_chars" != x; then
58469 58452 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58470 58453 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58471 58454 fi
58472 58455
58473 58456
58474 58457 windows_path="$new_path"
58475 58458 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58476 58459 unix_path=`$CYGPATH -u "$windows_path"`
58477 58460 new_path="$unix_path"
58478 58461 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58479 58462 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58480 58463 new_path="$unix_path"
58481 58464 fi
58482 58465
58483 58466 if test "x$path" != "x$new_path"; then
58484 58467 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58485 58468 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58486 58469 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58487 58470 fi
58488 58471
58489 58472 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58490 58473 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58491 58474
58492 58475 else
58493 58476 # We're on a unix platform. Hooray! :)
58494 58477 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58495 58478 has_space=`$ECHO "$path" | $GREP " "`
58496 58479 if test "x$has_space" != x; then
58497 58480 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58498 58481 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58499 58482 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58500 58483 fi
58501 58484
58502 58485 # Use eval to expand a potential ~
58503 58486 eval path="$path"
58504 58487 if test ! -f "$path" && test ! -d "$path"; then
58505 58488 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58506 58489 fi
58507 58490
58508 58491 if test -d "$path"; then
58509 58492 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
58510 58493 else
58511 58494 dir="`$DIRNAME "$path"`"
58512 58495 base="`$BASENAME "$path"`"
58513 58496 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58514 58497 fi
58515 58498 fi
58516 58499 fi
58517 58500
58518 58501
58519 58502 # Only process if variable expands to non-empty
58520 58503
58521 58504 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
58522 58505 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58523 58506
58524 58507 # Input might be given as Windows format, start by converting to
58525 58508 # unix format.
58526 58509 path="$POTENTIAL_FREETYPE_LIB_PATH"
58527 58510 new_path=`$CYGPATH -u "$path"`
58528 58511
58529 58512 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58530 58513 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58531 58514 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58532 58515 # "foo.exe" is OK but "foo" is an error.
58533 58516 #
58534 58517 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58535 58518 # It is also a way to make sure we got the proper file name for the real test later on.
58536 58519 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58537 58520 if test "x$test_shortpath" = x; then
58538 58521 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58539 58522 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58540 58523 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
58541 58524 fi
58542 58525
58543 58526 # Call helper function which possibly converts this using DOS-style short mode.
58544 58527 # If so, the updated path is stored in $new_path.
58545 58528
58546 58529 input_path="$new_path"
58547 58530 # Check if we need to convert this using DOS-style short mode. If the path
58548 58531 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58549 58532 # take no chances and rewrite it.
58550 58533 # Note: m4 eats our [], so we need to use [ and ] instead.
58551 58534 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58552 58535 if test "x$has_forbidden_chars" != x; then
58553 58536 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58554 58537 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58555 58538 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58556 58539 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58557 58540 # Going to short mode and back again did indeed matter. Since short mode is
58558 58541 # case insensitive, let's make it lowercase to improve readability.
58559 58542 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58560 58543 # Now convert it back to Unix-style (cygpath)
58561 58544 input_path=`$CYGPATH -u "$shortmode_path"`
58562 58545 new_path="$input_path"
58563 58546 fi
58564 58547 fi
58565 58548
58566 58549 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58567 58550 if test "x$test_cygdrive_prefix" = x; then
58568 58551 # As a simple fix, exclude /usr/bin since it's not a real path.
58569 58552 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58570 58553 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58571 58554 # a path prefixed by /cygdrive for fixpath to work.
58572 58555 new_path="$CYGWIN_ROOT_PATH$input_path"
58573 58556 fi
58574 58557 fi
58575 58558
58576 58559
58577 58560 if test "x$path" != "x$new_path"; then
58578 58561 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58579 58562 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58580 58563 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58581 58564 fi
58582 58565
58583 58566 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58584 58567
58585 58568 path="$POTENTIAL_FREETYPE_LIB_PATH"
58586 58569 has_colon=`$ECHO $path | $GREP ^.:`
58587 58570 new_path="$path"
58588 58571 if test "x$has_colon" = x; then
58589 58572 # Not in mixed or Windows style, start by that.
58590 58573 new_path=`cmd //c echo $path`
58591 58574 fi
58592 58575
58593 58576
58594 58577 input_path="$new_path"
58595 58578 # Check if we need to convert this using DOS-style short mode. If the path
58596 58579 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58597 58580 # take no chances and rewrite it.
58598 58581 # Note: m4 eats our [], so we need to use [ and ] instead.
58599 58582 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58600 58583 if test "x$has_forbidden_chars" != x; then
58601 58584 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58602 58585 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58603 58586 fi
58604 58587
58605 58588
58606 58589 windows_path="$new_path"
58607 58590 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58608 58591 unix_path=`$CYGPATH -u "$windows_path"`
58609 58592 new_path="$unix_path"
58610 58593 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58611 58594 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58612 58595 new_path="$unix_path"
58613 58596 fi
58614 58597
58615 58598 if test "x$path" != "x$new_path"; then
58616 58599 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58617 58600 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58618 58601 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58619 58602 fi
58620 58603
58621 58604 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58622 58605 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58623 58606
58624 58607 else
58625 58608 # We're on a unix platform. Hooray! :)
58626 58609 path="$POTENTIAL_FREETYPE_LIB_PATH"
58627 58610 has_space=`$ECHO "$path" | $GREP " "`
58628 58611 if test "x$has_space" != x; then
58629 58612 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58630 58613 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58631 58614 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58632 58615 fi
58633 58616
58634 58617 # Use eval to expand a potential ~
58635 58618 eval path="$path"
58636 58619 if test ! -f "$path" && test ! -d "$path"; then
58637 58620 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58638 58621 fi
58639 58622
58640 58623 if test -d "$path"; then
58641 58624 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
58642 58625 else
58643 58626 dir="`$DIRNAME "$path"`"
58644 58627 base="`$BASENAME "$path"`"
58645 58628 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58646 58629 fi
58647 58630 fi
58648 58631 fi
58649 58632
58650 58633
58651 58634 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58652 58635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
58653 58636 $as_echo_n "checking for freetype includes... " >&6; }
58654 58637 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
58655 58638 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
58656 58639 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
58657 58640 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
58658 58641 $as_echo_n "checking for freetype libraries... " >&6; }
58659 58642 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
58660 58643 $as_echo "$FREETYPE_LIB_PATH" >&6; }
58661 58644 fi
58662 58645
58663 58646 fi
58664 58647 if test "x$FOUND_FREETYPE" != xyes; then
58665 58648 FREETYPE_BASE_DIR="$HOME/freetype"
58666 58649
58667 58650 windows_path="$FREETYPE_BASE_DIR"
58668 58651 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58669 58652 unix_path=`$CYGPATH -u "$windows_path"`
58670 58653 FREETYPE_BASE_DIR="$unix_path"
58671 58654 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58672 58655 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58673 58656 FREETYPE_BASE_DIR="$unix_path"
58674 58657 fi
58675 58658
58676 58659 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
58677 58660
58678 58661 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
58679 58662 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib64"
58680 58663 METHOD="well-known location"
58681 58664
58682 58665 # Let's start with an optimistic view of the world :-)
58683 58666 FOUND_FREETYPE=yes
58684 58667
58685 58668 # First look for the canonical freetype main include file ft2build.h.
58686 58669 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
58687 58670 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
58688 58671 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
58689 58672 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
58690 58673 # Fail.
58691 58674 FOUND_FREETYPE=no
58692 58675 fi
58693 58676 fi
58694 58677
58695 58678 if test "x$FOUND_FREETYPE" = xyes; then
58696 58679 # Include file found, let's continue the sanity check.
58697 58680 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
58698 58681 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
58699 58682
58700 58683 # Reset to default value
58701 58684 FREETYPE_BASE_NAME=freetype
58702 58685 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58703 58686 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
58704 58687 if test "x$OPENJDK_TARGET_OS" = xmacosx \
58705 58688 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
58706 58689 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
58707 58690 # for the .6 version explicitly.
58708 58691 FREETYPE_BASE_NAME=freetype.6
58709 58692 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
58710 58693 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
58711 58694 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
58712 58695 else
58713 58696 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
58714 58697 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
58715 58698 FOUND_FREETYPE=no
58716 58699 fi
58717 58700 else
58718 58701 if test "x$OPENJDK_TARGET_OS" = xwindows; then
58719 58702 # On Windows, we will need both .lib and .dll file.
58720 58703 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
58721 58704 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
58722 58705 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
58723 58706 FOUND_FREETYPE=no
58724 58707 fi
58725 58708 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
58726 58709 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
58727 58710 # Found lib in isa dir, use that instead.
58728 58711 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
58729 58712 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
58730 58713 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
58731 58714 fi
58732 58715 fi
58733 58716 fi
58734 58717
58735 58718 if test "x$FOUND_FREETYPE" = xyes; then
58736 58719
58737 58720 # Only process if variable expands to non-empty
58738 58721
58739 58722 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
58740 58723 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58741 58724
58742 58725 # Input might be given as Windows format, start by converting to
58743 58726 # unix format.
58744 58727 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58745 58728 new_path=`$CYGPATH -u "$path"`
58746 58729
58747 58730 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58748 58731 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58749 58732 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58750 58733 # "foo.exe" is OK but "foo" is an error.
58751 58734 #
58752 58735 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58753 58736 # It is also a way to make sure we got the proper file name for the real test later on.
58754 58737 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58755 58738 if test "x$test_shortpath" = x; then
58756 58739 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58757 58740 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58758 58741 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
58759 58742 fi
58760 58743
58761 58744 # Call helper function which possibly converts this using DOS-style short mode.
58762 58745 # If so, the updated path is stored in $new_path.
58763 58746
58764 58747 input_path="$new_path"
58765 58748 # Check if we need to convert this using DOS-style short mode. If the path
58766 58749 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58767 58750 # take no chances and rewrite it.
58768 58751 # Note: m4 eats our [], so we need to use [ and ] instead.
58769 58752 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58770 58753 if test "x$has_forbidden_chars" != x; then
58771 58754 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58772 58755 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58773 58756 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58774 58757 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58775 58758 # Going to short mode and back again did indeed matter. Since short mode is
58776 58759 # case insensitive, let's make it lowercase to improve readability.
58777 58760 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58778 58761 # Now convert it back to Unix-style (cygpath)
58779 58762 input_path=`$CYGPATH -u "$shortmode_path"`
58780 58763 new_path="$input_path"
58781 58764 fi
58782 58765 fi
58783 58766
58784 58767 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58785 58768 if test "x$test_cygdrive_prefix" = x; then
58786 58769 # As a simple fix, exclude /usr/bin since it's not a real path.
58787 58770 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58788 58771 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58789 58772 # a path prefixed by /cygdrive for fixpath to work.
58790 58773 new_path="$CYGWIN_ROOT_PATH$input_path"
58791 58774 fi
58792 58775 fi
58793 58776
58794 58777
58795 58778 if test "x$path" != "x$new_path"; then
58796 58779 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58797 58780 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58798 58781 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58799 58782 fi
58800 58783
58801 58784 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58802 58785
58803 58786 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58804 58787 has_colon=`$ECHO $path | $GREP ^.:`
58805 58788 new_path="$path"
58806 58789 if test "x$has_colon" = x; then
58807 58790 # Not in mixed or Windows style, start by that.
58808 58791 new_path=`cmd //c echo $path`
58809 58792 fi
58810 58793
58811 58794
58812 58795 input_path="$new_path"
58813 58796 # Check if we need to convert this using DOS-style short mode. If the path
58814 58797 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58815 58798 # take no chances and rewrite it.
58816 58799 # Note: m4 eats our [], so we need to use [ and ] instead.
58817 58800 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58818 58801 if test "x$has_forbidden_chars" != x; then
58819 58802 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58820 58803 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58821 58804 fi
58822 58805
58823 58806
58824 58807 windows_path="$new_path"
58825 58808 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58826 58809 unix_path=`$CYGPATH -u "$windows_path"`
58827 58810 new_path="$unix_path"
58828 58811 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58829 58812 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58830 58813 new_path="$unix_path"
58831 58814 fi
58832 58815
58833 58816 if test "x$path" != "x$new_path"; then
58834 58817 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
58835 58818 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
58836 58819 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
58837 58820 fi
58838 58821
58839 58822 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58840 58823 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58841 58824
58842 58825 else
58843 58826 # We're on a unix platform. Hooray! :)
58844 58827 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
58845 58828 has_space=`$ECHO "$path" | $GREP " "`
58846 58829 if test "x$has_space" != x; then
58847 58830 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
58848 58831 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
58849 58832 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58850 58833 fi
58851 58834
58852 58835 # Use eval to expand a potential ~
58853 58836 eval path="$path"
58854 58837 if test ! -f "$path" && test ! -d "$path"; then
58855 58838 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58856 58839 fi
58857 58840
58858 58841 if test -d "$path"; then
58859 58842 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
58860 58843 else
58861 58844 dir="`$DIRNAME "$path"`"
58862 58845 base="`$BASENAME "$path"`"
58863 58846 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58864 58847 fi
58865 58848 fi
58866 58849 fi
58867 58850
58868 58851
58869 58852 # Only process if variable expands to non-empty
58870 58853
58871 58854 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
58872 58855 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58873 58856
58874 58857 # Input might be given as Windows format, start by converting to
58875 58858 # unix format.
58876 58859 path="$POTENTIAL_FREETYPE_LIB_PATH"
58877 58860 new_path=`$CYGPATH -u "$path"`
58878 58861
58879 58862 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
58880 58863 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
58881 58864 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
58882 58865 # "foo.exe" is OK but "foo" is an error.
58883 58866 #
58884 58867 # This test is therefore slightly more accurate than "test -f" to check for file precense.
58885 58868 # It is also a way to make sure we got the proper file name for the real test later on.
58886 58869 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
58887 58870 if test "x$test_shortpath" = x; then
58888 58871 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58889 58872 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58890 58873 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
58891 58874 fi
58892 58875
58893 58876 # Call helper function which possibly converts this using DOS-style short mode.
58894 58877 # If so, the updated path is stored in $new_path.
58895 58878
58896 58879 input_path="$new_path"
58897 58880 # Check if we need to convert this using DOS-style short mode. If the path
58898 58881 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58899 58882 # take no chances and rewrite it.
58900 58883 # Note: m4 eats our [], so we need to use [ and ] instead.
58901 58884 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
58902 58885 if test "x$has_forbidden_chars" != x; then
58903 58886 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58904 58887 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
58905 58888 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
58906 58889 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
58907 58890 # Going to short mode and back again did indeed matter. Since short mode is
58908 58891 # case insensitive, let's make it lowercase to improve readability.
58909 58892 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58910 58893 # Now convert it back to Unix-style (cygpath)
58911 58894 input_path=`$CYGPATH -u "$shortmode_path"`
58912 58895 new_path="$input_path"
58913 58896 fi
58914 58897 fi
58915 58898
58916 58899 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
58917 58900 if test "x$test_cygdrive_prefix" = x; then
58918 58901 # As a simple fix, exclude /usr/bin since it's not a real path.
58919 58902 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
58920 58903 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
58921 58904 # a path prefixed by /cygdrive for fixpath to work.
58922 58905 new_path="$CYGWIN_ROOT_PATH$input_path"
58923 58906 fi
58924 58907 fi
58925 58908
58926 58909
58927 58910 if test "x$path" != "x$new_path"; then
58928 58911 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58929 58912 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58930 58913 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58931 58914 fi
58932 58915
58933 58916 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58934 58917
58935 58918 path="$POTENTIAL_FREETYPE_LIB_PATH"
58936 58919 has_colon=`$ECHO $path | $GREP ^.:`
58937 58920 new_path="$path"
58938 58921 if test "x$has_colon" = x; then
58939 58922 # Not in mixed or Windows style, start by that.
58940 58923 new_path=`cmd //c echo $path`
58941 58924 fi
58942 58925
58943 58926
58944 58927 input_path="$new_path"
58945 58928 # Check if we need to convert this using DOS-style short mode. If the path
58946 58929 # contains just simple characters, use it. Otherwise (spaces, weird characters),
58947 58930 # take no chances and rewrite it.
58948 58931 # Note: m4 eats our [], so we need to use [ and ] instead.
58949 58932 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
58950 58933 if test "x$has_forbidden_chars" != x; then
58951 58934 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
58952 58935 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
58953 58936 fi
58954 58937
58955 58938
58956 58939 windows_path="$new_path"
58957 58940 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
58958 58941 unix_path=`$CYGPATH -u "$windows_path"`
58959 58942 new_path="$unix_path"
58960 58943 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
58961 58944 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
58962 58945 new_path="$unix_path"
58963 58946 fi
58964 58947
58965 58948 if test "x$path" != "x$new_path"; then
58966 58949 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
58967 58950 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
58968 58951 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
58969 58952 fi
58970 58953
58971 58954 # Save the first 10 bytes of this path to the storage, so fixpath can work.
58972 58955 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
58973 58956
58974 58957 else
58975 58958 # We're on a unix platform. Hooray! :)
58976 58959 path="$POTENTIAL_FREETYPE_LIB_PATH"
58977 58960 has_space=`$ECHO "$path" | $GREP " "`
58978 58961 if test "x$has_space" != x; then
58979 58962 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
58980 58963 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
58981 58964 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
58982 58965 fi
58983 58966
58984 58967 # Use eval to expand a potential ~
58985 58968 eval path="$path"
58986 58969 if test ! -f "$path" && test ! -d "$path"; then
58987 58970 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
58988 58971 fi
58989 58972
58990 58973 if test -d "$path"; then
58991 58974 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
58992 58975 else
58993 58976 dir="`$DIRNAME "$path"`"
58994 58977 base="`$BASENAME "$path"`"
58995 58978 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
58996 58979 fi
58997 58980 fi
58998 58981 fi
58999 58982
59000 58983
59001 58984 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59002 58985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
59003 58986 $as_echo_n "checking for freetype includes... " >&6; }
59004 58987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
59005 58988 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
59006 58989 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
59007 58990 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
59008 58991 $as_echo_n "checking for freetype libraries... " >&6; }
59009 58992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
59010 58993 $as_echo "$FREETYPE_LIB_PATH" >&6; }
59011 58994 fi
59012 58995
59013 58996 else
59014 58997
59015 58998 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
59016 58999 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
59017 59000 METHOD="well-known location"
59018 59001
59019 59002 # Let's start with an optimistic view of the world :-)
59020 59003 FOUND_FREETYPE=yes
59021 59004
59022 59005 # First look for the canonical freetype main include file ft2build.h.
59023 59006 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59024 59007 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
59025 59008 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
59026 59009 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59027 59010 # Fail.
59028 59011 FOUND_FREETYPE=no
59029 59012 fi
59030 59013 fi
59031 59014
59032 59015 if test "x$FOUND_FREETYPE" = xyes; then
59033 59016 # Include file found, let's continue the sanity check.
59034 59017 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
59035 59018 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
59036 59019
59037 59020 # Reset to default value
59038 59021 FREETYPE_BASE_NAME=freetype
59039 59022 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59040 59023 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
59041 59024 if test "x$OPENJDK_TARGET_OS" = xmacosx \
59042 59025 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
59043 59026 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
59044 59027 # for the .6 version explicitly.
59045 59028 FREETYPE_BASE_NAME=freetype.6
59046 59029 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59047 59030 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
59048 59031 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
59049 59032 else
59050 59033 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
59051 59034 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
59052 59035 FOUND_FREETYPE=no
59053 59036 fi
59054 59037 else
59055 59038 if test "x$OPENJDK_TARGET_OS" = xwindows; then
59056 59039 # On Windows, we will need both .lib and .dll file.
59057 59040 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
59058 59041 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
59059 59042 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
59060 59043 FOUND_FREETYPE=no
59061 59044 fi
59062 59045 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
59063 59046 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
59064 59047 # Found lib in isa dir, use that instead.
59065 59048 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
59066 59049 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
59067 59050 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
59068 59051 fi
59069 59052 fi
59070 59053 fi
59071 59054
59072 59055 if test "x$FOUND_FREETYPE" = xyes; then
59073 59056
59074 59057 # Only process if variable expands to non-empty
59075 59058
59076 59059 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
59077 59060 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59078 59061
59079 59062 # Input might be given as Windows format, start by converting to
59080 59063 # unix format.
59081 59064 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59082 59065 new_path=`$CYGPATH -u "$path"`
59083 59066
59084 59067 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
59085 59068 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
59086 59069 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
59087 59070 # "foo.exe" is OK but "foo" is an error.
59088 59071 #
59089 59072 # This test is therefore slightly more accurate than "test -f" to check for file precense.
59090 59073 # It is also a way to make sure we got the proper file name for the real test later on.
59091 59074 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
59092 59075 if test "x$test_shortpath" = x; then
59093 59076 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59094 59077 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59095 59078 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
59096 59079 fi
59097 59080
59098 59081 # Call helper function which possibly converts this using DOS-style short mode.
59099 59082 # If so, the updated path is stored in $new_path.
59100 59083
59101 59084 input_path="$new_path"
59102 59085 # Check if we need to convert this using DOS-style short mode. If the path
59103 59086 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59104 59087 # take no chances and rewrite it.
59105 59088 # Note: m4 eats our [], so we need to use [ and ] instead.
59106 59089 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
59107 59090 if test "x$has_forbidden_chars" != x; then
59108 59091 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59109 59092 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
59110 59093 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
59111 59094 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
59112 59095 # Going to short mode and back again did indeed matter. Since short mode is
59113 59096 # case insensitive, let's make it lowercase to improve readability.
59114 59097 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59115 59098 # Now convert it back to Unix-style (cygpath)
59116 59099 input_path=`$CYGPATH -u "$shortmode_path"`
59117 59100 new_path="$input_path"
59118 59101 fi
59119 59102 fi
59120 59103
59121 59104 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
59122 59105 if test "x$test_cygdrive_prefix" = x; then
59123 59106 # As a simple fix, exclude /usr/bin since it's not a real path.
59124 59107 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
59125 59108 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
59126 59109 # a path prefixed by /cygdrive for fixpath to work.
59127 59110 new_path="$CYGWIN_ROOT_PATH$input_path"
59128 59111 fi
59129 59112 fi
59130 59113
59131 59114
59132 59115 if test "x$path" != "x$new_path"; then
59133 59116 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59134 59117 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59135 59118 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59136 59119 fi
59137 59120
59138 59121 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59139 59122
59140 59123 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59141 59124 has_colon=`$ECHO $path | $GREP ^.:`
59142 59125 new_path="$path"
59143 59126 if test "x$has_colon" = x; then
59144 59127 # Not in mixed or Windows style, start by that.
59145 59128 new_path=`cmd //c echo $path`
59146 59129 fi
59147 59130
59148 59131
59149 59132 input_path="$new_path"
59150 59133 # Check if we need to convert this using DOS-style short mode. If the path
59151 59134 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59152 59135 # take no chances and rewrite it.
59153 59136 # Note: m4 eats our [], so we need to use [ and ] instead.
59154 59137 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
59155 59138 if test "x$has_forbidden_chars" != x; then
59156 59139 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59157 59140 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59158 59141 fi
59159 59142
59160 59143
59161 59144 windows_path="$new_path"
59162 59145 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59163 59146 unix_path=`$CYGPATH -u "$windows_path"`
59164 59147 new_path="$unix_path"
59165 59148 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59166 59149 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
59167 59150 new_path="$unix_path"
59168 59151 fi
59169 59152
59170 59153 if test "x$path" != "x$new_path"; then
59171 59154 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59172 59155 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59173 59156 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59174 59157 fi
59175 59158
59176 59159 # Save the first 10 bytes of this path to the storage, so fixpath can work.
59177 59160 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
59178 59161
59179 59162 else
59180 59163 # We're on a unix platform. Hooray! :)
59181 59164 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59182 59165 has_space=`$ECHO "$path" | $GREP " "`
59183 59166 if test "x$has_space" != x; then
59184 59167 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59185 59168 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59186 59169 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
59187 59170 fi
59188 59171
59189 59172 # Use eval to expand a potential ~
59190 59173 eval path="$path"
59191 59174 if test ! -f "$path" && test ! -d "$path"; then
59192 59175 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
59193 59176 fi
59194 59177
59195 59178 if test -d "$path"; then
59196 59179 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
59197 59180 else
59198 59181 dir="`$DIRNAME "$path"`"
59199 59182 base="`$BASENAME "$path"`"
59200 59183 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
59201 59184 fi
59202 59185 fi
59203 59186 fi
59204 59187
59205 59188
59206 59189 # Only process if variable expands to non-empty
59207 59190
59208 59191 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
59209 59192 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59210 59193
59211 59194 # Input might be given as Windows format, start by converting to
59212 59195 # unix format.
59213 59196 path="$POTENTIAL_FREETYPE_LIB_PATH"
59214 59197 new_path=`$CYGPATH -u "$path"`
59215 59198
59216 59199 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
59217 59200 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
59218 59201 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
59219 59202 # "foo.exe" is OK but "foo" is an error.
59220 59203 #
59221 59204 # This test is therefore slightly more accurate than "test -f" to check for file precense.
59222 59205 # It is also a way to make sure we got the proper file name for the real test later on.
59223 59206 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
59224 59207 if test "x$test_shortpath" = x; then
59225 59208 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
59226 59209 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
59227 59210 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
59228 59211 fi
59229 59212
59230 59213 # Call helper function which possibly converts this using DOS-style short mode.
59231 59214 # If so, the updated path is stored in $new_path.
59232 59215
59233 59216 input_path="$new_path"
59234 59217 # Check if we need to convert this using DOS-style short mode. If the path
59235 59218 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59236 59219 # take no chances and rewrite it.
59237 59220 # Note: m4 eats our [], so we need to use [ and ] instead.
59238 59221 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
59239 59222 if test "x$has_forbidden_chars" != x; then
59240 59223 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59241 59224 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
59242 59225 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
59243 59226 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
59244 59227 # Going to short mode and back again did indeed matter. Since short mode is
59245 59228 # case insensitive, let's make it lowercase to improve readability.
59246 59229 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59247 59230 # Now convert it back to Unix-style (cygpath)
59248 59231 input_path=`$CYGPATH -u "$shortmode_path"`
59249 59232 new_path="$input_path"
59250 59233 fi
59251 59234 fi
59252 59235
59253 59236 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
59254 59237 if test "x$test_cygdrive_prefix" = x; then
59255 59238 # As a simple fix, exclude /usr/bin since it's not a real path.
59256 59239 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
59257 59240 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
59258 59241 # a path prefixed by /cygdrive for fixpath to work.
59259 59242 new_path="$CYGWIN_ROOT_PATH$input_path"
59260 59243 fi
59261 59244 fi
59262 59245
59263 59246
59264 59247 if test "x$path" != "x$new_path"; then
59265 59248 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
59266 59249 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
59267 59250 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
59268 59251 fi
59269 59252
59270 59253 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59271 59254
59272 59255 path="$POTENTIAL_FREETYPE_LIB_PATH"
59273 59256 has_colon=`$ECHO $path | $GREP ^.:`
59274 59257 new_path="$path"
59275 59258 if test "x$has_colon" = x; then
59276 59259 # Not in mixed or Windows style, start by that.
59277 59260 new_path=`cmd //c echo $path`
59278 59261 fi
59279 59262
59280 59263
59281 59264 input_path="$new_path"
59282 59265 # Check if we need to convert this using DOS-style short mode. If the path
59283 59266 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59284 59267 # take no chances and rewrite it.
59285 59268 # Note: m4 eats our [], so we need to use [ and ] instead.
59286 59269 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
59287 59270 if test "x$has_forbidden_chars" != x; then
59288 59271 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59289 59272 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59290 59273 fi
59291 59274
59292 59275
59293 59276 windows_path="$new_path"
59294 59277 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59295 59278 unix_path=`$CYGPATH -u "$windows_path"`
59296 59279 new_path="$unix_path"
59297 59280 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59298 59281 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
59299 59282 new_path="$unix_path"
59300 59283 fi
59301 59284
59302 59285 if test "x$path" != "x$new_path"; then
59303 59286 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
59304 59287 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
59305 59288 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
59306 59289 fi
59307 59290
59308 59291 # Save the first 10 bytes of this path to the storage, so fixpath can work.
59309 59292 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
59310 59293
59311 59294 else
59312 59295 # We're on a unix platform. Hooray! :)
59313 59296 path="$POTENTIAL_FREETYPE_LIB_PATH"
59314 59297 has_space=`$ECHO "$path" | $GREP " "`
59315 59298 if test "x$has_space" != x; then
59316 59299 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
59317 59300 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
59318 59301 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
59319 59302 fi
59320 59303
59321 59304 # Use eval to expand a potential ~
59322 59305 eval path="$path"
59323 59306 if test ! -f "$path" && test ! -d "$path"; then
59324 59307 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
59325 59308 fi
59326 59309
59327 59310 if test -d "$path"; then
59328 59311 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
59329 59312 else
59330 59313 dir="`$DIRNAME "$path"`"
59331 59314 base="`$BASENAME "$path"`"
59332 59315 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
59333 59316 fi
59334 59317 fi
59335 59318 fi
59336 59319
59337 59320
59338 59321 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59339 59322 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
59340 59323 $as_echo_n "checking for freetype includes... " >&6; }
59341 59324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
59342 59325 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
59343 59326 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
59344 59327 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
59345 59328 $as_echo_n "checking for freetype libraries... " >&6; }
59346 59329 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
59347 59330 $as_echo "$FREETYPE_LIB_PATH" >&6; }
59348 59331 fi
59349 59332
59350 59333 fi
59351 59334 if test "x$FOUND_FREETYPE" != xyes && test -d $FREETYPE_BASE_DIR \
59352 59335 && test -s "$FREETYPE_BASE_DIR/builds/windows/vc2010/freetype.vcxproj" && test "x$MSBUILD" != x; then
59353 59336 # Source is available, as a last resort try to build freetype in default location
59354 59337
59355 59338 FREETYPE_SRC_PATH="$FREETYPE_BASE_DIR"
59356 59339 BUILD_FREETYPE=yes
59357 59340
59358 59341 # Check if the freetype sources are acessible..
59359 59342 if ! test -d $FREETYPE_SRC_PATH; then
59360 59343 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&5
59361 59344 $as_echo "$as_me: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&2;}
59362 59345 BUILD_FREETYPE=no
59363 59346 fi
59364 59347 # ..and contain a vc2010 project file
59365 59348 vcxproj_path="$FREETYPE_SRC_PATH/builds/windows/vc2010/freetype.vcxproj"
59366 59349 if test "x$BUILD_FREETYPE" = xyes && ! test -s $vcxproj_path; then
59367 59350 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&5
59368 59351 $as_echo "$as_me: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&2;}
59369 59352 BUILD_FREETYPE=no
59370 59353 fi
59371 59354 # Now check if configure found a version of 'msbuild.exe'
59372 59355 if test "x$BUILD_FREETYPE" = xyes && test "x$MSBUILD" == x ; then
59373 59356 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&5
59374 59357 $as_echo "$as_me: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&2;}
59375 59358 BUILD_FREETYPE=no
59376 59359 fi
59377 59360
59378 59361 # Ready to go..
59379 59362 if test "x$BUILD_FREETYPE" = xyes; then
59380 59363 # msbuild requires trailing slashes for output directories
59381 59364 freetype_lib_path="$FREETYPE_SRC_PATH/lib$OPENJDK_TARGET_CPU_BITS/"
59382 59365 freetype_lib_path_unix="$freetype_lib_path"
59383 59366 freetype_obj_path="$FREETYPE_SRC_PATH/obj$OPENJDK_TARGET_CPU_BITS/"
59384 59367
59385 59368 unix_path="$vcxproj_path"
59386 59369 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59387 59370 windows_path=`$CYGPATH -m "$unix_path"`
59388 59371 vcxproj_path="$windows_path"
59389 59372 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59390 59373 windows_path=`cmd //c echo $unix_path`
59391 59374 vcxproj_path="$windows_path"
59392 59375 fi
59393 59376
59394 59377
59395 59378 unix_path="$freetype_lib_path"
59396 59379 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59397 59380 windows_path=`$CYGPATH -m "$unix_path"`
59398 59381 freetype_lib_path="$windows_path"
59399 59382 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59400 59383 windows_path=`cmd //c echo $unix_path`
59401 59384 freetype_lib_path="$windows_path"
59402 59385 fi
59403 59386
59404 59387
59405 59388 unix_path="$freetype_obj_path"
59406 59389 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59407 59390 windows_path=`$CYGPATH -m "$unix_path"`
59408 59391 freetype_obj_path="$windows_path"
59409 59392 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59410 59393 windows_path=`cmd //c echo $unix_path`
59411 59394 freetype_obj_path="$windows_path"
59412 59395 fi
59413 59396
59414 59397 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
59415 59398 freetype_platform=x64
59416 59399 else
59417 59400 freetype_platform=win32
59418 59401 fi
59419 59402
59420 59403 # The original freetype project file is for VS 2010 (i.e. 'v100'),
59421 59404 # so we have to adapt the toolset if building with any other toolsed (i.e. SDK).
59422 59405 # Currently 'PLATFORM_TOOLSET' is set in 'TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT'/
59423 59406 # 'TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT' in toolchain_windows.m4
59424 59407 { $as_echo "$as_me:${as_lineno-$LINENO}: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&5
59425 59408 $as_echo "$as_me: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&6;}
59426 59409
59427 59410 # First we try to build the freetype.dll
59428 59411 $ECHO -e "@echo off\n"\
59429 59412 "$MSBUILD $vcxproj_path "\
59430 59413 "/p:PlatformToolset=$PLATFORM_TOOLSET "\
59431 59414 "/p:Configuration=\"Release Multithreaded\" "\
59432 59415 "/p:Platform=$freetype_platform "\
59433 59416 "/p:ConfigurationType=DynamicLibrary "\
59434 59417 "/p:TargetName=freetype "\
59435 59418 "/p:OutDir=\"$freetype_lib_path\" "\
59436 59419 "/p:IntDir=\"$freetype_obj_path\" > freetype.log" > freetype.bat
59437 59420 cmd /c freetype.bat
59438 59421
59439 59422 if test -s "$freetype_lib_path_unix/freetype.dll"; then
59440 59423 # If that succeeds we also build freetype.lib
59441 59424 $ECHO -e "@echo off\n"\
59442 59425 "$MSBUILD $vcxproj_path "\
59443 59426 "/p:PlatformToolset=$PLATFORM_TOOLSET "\
59444 59427 "/p:Configuration=\"Release Multithreaded\" "\
59445 59428 "/p:Platform=$freetype_platform "\
59446 59429 "/p:ConfigurationType=StaticLibrary "\
59447 59430 "/p:TargetName=freetype "\
59448 59431 "/p:OutDir=\"$freetype_lib_path\" "\
59449 59432 "/p:IntDir=\"$freetype_obj_path\" >> freetype.log" > freetype.bat
59450 59433 cmd /c freetype.bat
59451 59434
59452 59435 if test -s "$freetype_lib_path_unix/freetype.lib"; then
59453 59436 # Once we build both, lib and dll, set freetype lib and include path appropriately
59454 59437 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_SRC_PATH/include"
59455 59438 POTENTIAL_FREETYPE_LIB_PATH="$freetype_lib_path_unix"
59456 59439 { $as_echo "$as_me:${as_lineno-$LINENO}: Compiling freetype sources succeeded! (see freetype.log for build results)" >&5
59457 59440 $as_echo "$as_me: Compiling freetype sources succeeded! (see freetype.log for build results)" >&6;}
59458 59441 else
59459 59442 BUILD_FREETYPE=no
59460 59443 fi
59461 59444 else
59462 59445 BUILD_FREETYPE=no
59463 59446 fi
59464 59447 fi
59465 59448
59466 59449 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
59467 59450
59468 59451 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
59469 59452 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib64"
59470 59453 METHOD="well-known location"
59471 59454
59472 59455 # Let's start with an optimistic view of the world :-)
59473 59456 FOUND_FREETYPE=yes
59474 59457
59475 59458 # First look for the canonical freetype main include file ft2build.h.
59476 59459 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59477 59460 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
59478 59461 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
59479 59462 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59480 59463 # Fail.
59481 59464 FOUND_FREETYPE=no
59482 59465 fi
59483 59466 fi
59484 59467
59485 59468 if test "x$FOUND_FREETYPE" = xyes; then
59486 59469 # Include file found, let's continue the sanity check.
59487 59470 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
59488 59471 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
59489 59472
59490 59473 # Reset to default value
59491 59474 FREETYPE_BASE_NAME=freetype
59492 59475 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59493 59476 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
59494 59477 if test "x$OPENJDK_TARGET_OS" = xmacosx \
59495 59478 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
59496 59479 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
59497 59480 # for the .6 version explicitly.
59498 59481 FREETYPE_BASE_NAME=freetype.6
59499 59482 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59500 59483 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
59501 59484 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
59502 59485 else
59503 59486 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
59504 59487 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
59505 59488 FOUND_FREETYPE=no
59506 59489 fi
59507 59490 else
59508 59491 if test "x$OPENJDK_TARGET_OS" = xwindows; then
59509 59492 # On Windows, we will need both .lib and .dll file.
59510 59493 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
59511 59494 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
59512 59495 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
59513 59496 FOUND_FREETYPE=no
59514 59497 fi
59515 59498 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
59516 59499 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
59517 59500 # Found lib in isa dir, use that instead.
59518 59501 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
59519 59502 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
59520 59503 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
59521 59504 fi
59522 59505 fi
59523 59506 fi
59524 59507
59525 59508 if test "x$FOUND_FREETYPE" = xyes; then
59526 59509
59527 59510 # Only process if variable expands to non-empty
59528 59511
59529 59512 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
59530 59513 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59531 59514
59532 59515 # Input might be given as Windows format, start by converting to
59533 59516 # unix format.
59534 59517 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59535 59518 new_path=`$CYGPATH -u "$path"`
59536 59519
59537 59520 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
59538 59521 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
59539 59522 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
59540 59523 # "foo.exe" is OK but "foo" is an error.
59541 59524 #
59542 59525 # This test is therefore slightly more accurate than "test -f" to check for file precense.
59543 59526 # It is also a way to make sure we got the proper file name for the real test later on.
59544 59527 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
59545 59528 if test "x$test_shortpath" = x; then
59546 59529 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59547 59530 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59548 59531 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
59549 59532 fi
59550 59533
59551 59534 # Call helper function which possibly converts this using DOS-style short mode.
59552 59535 # If so, the updated path is stored in $new_path.
59553 59536
59554 59537 input_path="$new_path"
59555 59538 # Check if we need to convert this using DOS-style short mode. If the path
59556 59539 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59557 59540 # take no chances and rewrite it.
59558 59541 # Note: m4 eats our [], so we need to use [ and ] instead.
59559 59542 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
59560 59543 if test "x$has_forbidden_chars" != x; then
59561 59544 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59562 59545 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
59563 59546 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
59564 59547 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
59565 59548 # Going to short mode and back again did indeed matter. Since short mode is
59566 59549 # case insensitive, let's make it lowercase to improve readability.
59567 59550 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59568 59551 # Now convert it back to Unix-style (cygpath)
59569 59552 input_path=`$CYGPATH -u "$shortmode_path"`
59570 59553 new_path="$input_path"
59571 59554 fi
59572 59555 fi
59573 59556
59574 59557 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
59575 59558 if test "x$test_cygdrive_prefix" = x; then
59576 59559 # As a simple fix, exclude /usr/bin since it's not a real path.
59577 59560 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
59578 59561 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
59579 59562 # a path prefixed by /cygdrive for fixpath to work.
59580 59563 new_path="$CYGWIN_ROOT_PATH$input_path"
59581 59564 fi
59582 59565 fi
59583 59566
59584 59567
59585 59568 if test "x$path" != "x$new_path"; then
59586 59569 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59587 59570 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59588 59571 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59589 59572 fi
59590 59573
59591 59574 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59592 59575
59593 59576 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59594 59577 has_colon=`$ECHO $path | $GREP ^.:`
59595 59578 new_path="$path"
59596 59579 if test "x$has_colon" = x; then
59597 59580 # Not in mixed or Windows style, start by that.
59598 59581 new_path=`cmd //c echo $path`
59599 59582 fi
59600 59583
59601 59584
59602 59585 input_path="$new_path"
59603 59586 # Check if we need to convert this using DOS-style short mode. If the path
59604 59587 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59605 59588 # take no chances and rewrite it.
59606 59589 # Note: m4 eats our [], so we need to use [ and ] instead.
59607 59590 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
59608 59591 if test "x$has_forbidden_chars" != x; then
59609 59592 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59610 59593 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59611 59594 fi
59612 59595
59613 59596
59614 59597 windows_path="$new_path"
59615 59598 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59616 59599 unix_path=`$CYGPATH -u "$windows_path"`
59617 59600 new_path="$unix_path"
59618 59601 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59619 59602 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
59620 59603 new_path="$unix_path"
59621 59604 fi
59622 59605
59623 59606 if test "x$path" != "x$new_path"; then
59624 59607 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59625 59608 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59626 59609 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59627 59610 fi
59628 59611
59629 59612 # Save the first 10 bytes of this path to the storage, so fixpath can work.
59630 59613 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
59631 59614
59632 59615 else
59633 59616 # We're on a unix platform. Hooray! :)
59634 59617 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59635 59618 has_space=`$ECHO "$path" | $GREP " "`
59636 59619 if test "x$has_space" != x; then
59637 59620 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59638 59621 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59639 59622 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
59640 59623 fi
59641 59624
59642 59625 # Use eval to expand a potential ~
59643 59626 eval path="$path"
59644 59627 if test ! -f "$path" && test ! -d "$path"; then
59645 59628 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
59646 59629 fi
59647 59630
59648 59631 if test -d "$path"; then
59649 59632 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
59650 59633 else
59651 59634 dir="`$DIRNAME "$path"`"
59652 59635 base="`$BASENAME "$path"`"
59653 59636 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
59654 59637 fi
59655 59638 fi
59656 59639 fi
59657 59640
59658 59641
59659 59642 # Only process if variable expands to non-empty
59660 59643
59661 59644 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
59662 59645 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59663 59646
59664 59647 # Input might be given as Windows format, start by converting to
59665 59648 # unix format.
59666 59649 path="$POTENTIAL_FREETYPE_LIB_PATH"
59667 59650 new_path=`$CYGPATH -u "$path"`
59668 59651
59669 59652 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
59670 59653 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
59671 59654 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
59672 59655 # "foo.exe" is OK but "foo" is an error.
59673 59656 #
59674 59657 # This test is therefore slightly more accurate than "test -f" to check for file precense.
59675 59658 # It is also a way to make sure we got the proper file name for the real test later on.
59676 59659 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
59677 59660 if test "x$test_shortpath" = x; then
59678 59661 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
59679 59662 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
59680 59663 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
59681 59664 fi
59682 59665
59683 59666 # Call helper function which possibly converts this using DOS-style short mode.
59684 59667 # If so, the updated path is stored in $new_path.
59685 59668
59686 59669 input_path="$new_path"
59687 59670 # Check if we need to convert this using DOS-style short mode. If the path
59688 59671 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59689 59672 # take no chances and rewrite it.
59690 59673 # Note: m4 eats our [], so we need to use [ and ] instead.
59691 59674 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
59692 59675 if test "x$has_forbidden_chars" != x; then
59693 59676 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59694 59677 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
59695 59678 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
59696 59679 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
59697 59680 # Going to short mode and back again did indeed matter. Since short mode is
59698 59681 # case insensitive, let's make it lowercase to improve readability.
59699 59682 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59700 59683 # Now convert it back to Unix-style (cygpath)
59701 59684 input_path=`$CYGPATH -u "$shortmode_path"`
59702 59685 new_path="$input_path"
59703 59686 fi
59704 59687 fi
59705 59688
59706 59689 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
59707 59690 if test "x$test_cygdrive_prefix" = x; then
59708 59691 # As a simple fix, exclude /usr/bin since it's not a real path.
59709 59692 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
59710 59693 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
59711 59694 # a path prefixed by /cygdrive for fixpath to work.
59712 59695 new_path="$CYGWIN_ROOT_PATH$input_path"
59713 59696 fi
59714 59697 fi
59715 59698
59716 59699
59717 59700 if test "x$path" != "x$new_path"; then
59718 59701 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
59719 59702 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
59720 59703 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
59721 59704 fi
59722 59705
59723 59706 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59724 59707
59725 59708 path="$POTENTIAL_FREETYPE_LIB_PATH"
59726 59709 has_colon=`$ECHO $path | $GREP ^.:`
59727 59710 new_path="$path"
59728 59711 if test "x$has_colon" = x; then
59729 59712 # Not in mixed or Windows style, start by that.
59730 59713 new_path=`cmd //c echo $path`
59731 59714 fi
59732 59715
59733 59716
59734 59717 input_path="$new_path"
59735 59718 # Check if we need to convert this using DOS-style short mode. If the path
59736 59719 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59737 59720 # take no chances and rewrite it.
59738 59721 # Note: m4 eats our [], so we need to use [ and ] instead.
59739 59722 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
59740 59723 if test "x$has_forbidden_chars" != x; then
59741 59724 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59742 59725 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59743 59726 fi
59744 59727
59745 59728
59746 59729 windows_path="$new_path"
59747 59730 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59748 59731 unix_path=`$CYGPATH -u "$windows_path"`
59749 59732 new_path="$unix_path"
59750 59733 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59751 59734 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
59752 59735 new_path="$unix_path"
59753 59736 fi
59754 59737
59755 59738 if test "x$path" != "x$new_path"; then
59756 59739 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
59757 59740 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
59758 59741 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
59759 59742 fi
59760 59743
59761 59744 # Save the first 10 bytes of this path to the storage, so fixpath can work.
59762 59745 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
59763 59746
59764 59747 else
59765 59748 # We're on a unix platform. Hooray! :)
59766 59749 path="$POTENTIAL_FREETYPE_LIB_PATH"
59767 59750 has_space=`$ECHO "$path" | $GREP " "`
59768 59751 if test "x$has_space" != x; then
59769 59752 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
59770 59753 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
59771 59754 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
59772 59755 fi
59773 59756
59774 59757 # Use eval to expand a potential ~
59775 59758 eval path="$path"
59776 59759 if test ! -f "$path" && test ! -d "$path"; then
59777 59760 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
59778 59761 fi
59779 59762
59780 59763 if test -d "$path"; then
59781 59764 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
59782 59765 else
59783 59766 dir="`$DIRNAME "$path"`"
59784 59767 base="`$BASENAME "$path"`"
59785 59768 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
59786 59769 fi
59787 59770 fi
59788 59771 fi
59789 59772
59790 59773
59791 59774 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59792 59775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
59793 59776 $as_echo_n "checking for freetype includes... " >&6; }
59794 59777 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
59795 59778 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
59796 59779 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
59797 59780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
59798 59781 $as_echo_n "checking for freetype libraries... " >&6; }
59799 59782 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
59800 59783 $as_echo "$FREETYPE_LIB_PATH" >&6; }
59801 59784 fi
59802 59785
59803 59786 else
59804 59787
59805 59788 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
59806 59789 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
59807 59790 METHOD="well-known location"
59808 59791
59809 59792 # Let's start with an optimistic view of the world :-)
59810 59793 FOUND_FREETYPE=yes
59811 59794
59812 59795 # First look for the canonical freetype main include file ft2build.h.
59813 59796 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59814 59797 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
59815 59798 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
59816 59799 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
59817 59800 # Fail.
59818 59801 FOUND_FREETYPE=no
59819 59802 fi
59820 59803 fi
59821 59804
59822 59805 if test "x$FOUND_FREETYPE" = xyes; then
59823 59806 # Include file found, let's continue the sanity check.
59824 59807 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
59825 59808 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
59826 59809
59827 59810 # Reset to default value
59828 59811 FREETYPE_BASE_NAME=freetype
59829 59812 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59830 59813 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
59831 59814 if test "x$OPENJDK_TARGET_OS" = xmacosx \
59832 59815 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
59833 59816 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
59834 59817 # for the .6 version explicitly.
59835 59818 FREETYPE_BASE_NAME=freetype.6
59836 59819 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
59837 59820 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
59838 59821 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
59839 59822 else
59840 59823 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
59841 59824 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
59842 59825 FOUND_FREETYPE=no
59843 59826 fi
59844 59827 else
59845 59828 if test "x$OPENJDK_TARGET_OS" = xwindows; then
59846 59829 # On Windows, we will need both .lib and .dll file.
59847 59830 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
59848 59831 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
59849 59832 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
59850 59833 FOUND_FREETYPE=no
59851 59834 fi
59852 59835 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
59853 59836 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
59854 59837 # Found lib in isa dir, use that instead.
59855 59838 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
59856 59839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
59857 59840 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
59858 59841 fi
59859 59842 fi
59860 59843 fi
59861 59844
59862 59845 if test "x$FOUND_FREETYPE" = xyes; then
59863 59846
59864 59847 # Only process if variable expands to non-empty
59865 59848
59866 59849 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
59867 59850 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59868 59851
59869 59852 # Input might be given as Windows format, start by converting to
59870 59853 # unix format.
59871 59854 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59872 59855 new_path=`$CYGPATH -u "$path"`
59873 59856
59874 59857 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
59875 59858 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
59876 59859 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
59877 59860 # "foo.exe" is OK but "foo" is an error.
59878 59861 #
59879 59862 # This test is therefore slightly more accurate than "test -f" to check for file precense.
59880 59863 # It is also a way to make sure we got the proper file name for the real test later on.
59881 59864 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
59882 59865 if test "x$test_shortpath" = x; then
59883 59866 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59884 59867 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59885 59868 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
59886 59869 fi
59887 59870
59888 59871 # Call helper function which possibly converts this using DOS-style short mode.
59889 59872 # If so, the updated path is stored in $new_path.
59890 59873
59891 59874 input_path="$new_path"
59892 59875 # Check if we need to convert this using DOS-style short mode. If the path
59893 59876 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59894 59877 # take no chances and rewrite it.
59895 59878 # Note: m4 eats our [], so we need to use [ and ] instead.
59896 59879 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
59897 59880 if test "x$has_forbidden_chars" != x; then
59898 59881 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59899 59882 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
59900 59883 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
59901 59884 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
59902 59885 # Going to short mode and back again did indeed matter. Since short mode is
59903 59886 # case insensitive, let's make it lowercase to improve readability.
59904 59887 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59905 59888 # Now convert it back to Unix-style (cygpath)
59906 59889 input_path=`$CYGPATH -u "$shortmode_path"`
59907 59890 new_path="$input_path"
59908 59891 fi
59909 59892 fi
59910 59893
59911 59894 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
59912 59895 if test "x$test_cygdrive_prefix" = x; then
59913 59896 # As a simple fix, exclude /usr/bin since it's not a real path.
59914 59897 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
59915 59898 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
59916 59899 # a path prefixed by /cygdrive for fixpath to work.
59917 59900 new_path="$CYGWIN_ROOT_PATH$input_path"
59918 59901 fi
59919 59902 fi
59920 59903
59921 59904
59922 59905 if test "x$path" != "x$new_path"; then
59923 59906 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59924 59907 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59925 59908 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59926 59909 fi
59927 59910
59928 59911 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59929 59912
59930 59913 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59931 59914 has_colon=`$ECHO $path | $GREP ^.:`
59932 59915 new_path="$path"
59933 59916 if test "x$has_colon" = x; then
59934 59917 # Not in mixed or Windows style, start by that.
59935 59918 new_path=`cmd //c echo $path`
59936 59919 fi
59937 59920
59938 59921
59939 59922 input_path="$new_path"
59940 59923 # Check if we need to convert this using DOS-style short mode. If the path
59941 59924 # contains just simple characters, use it. Otherwise (spaces, weird characters),
59942 59925 # take no chances and rewrite it.
59943 59926 # Note: m4 eats our [], so we need to use [ and ] instead.
59944 59927 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
59945 59928 if test "x$has_forbidden_chars" != x; then
59946 59929 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
59947 59930 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
59948 59931 fi
59949 59932
59950 59933
59951 59934 windows_path="$new_path"
59952 59935 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
59953 59936 unix_path=`$CYGPATH -u "$windows_path"`
59954 59937 new_path="$unix_path"
59955 59938 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
59956 59939 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
59957 59940 new_path="$unix_path"
59958 59941 fi
59959 59942
59960 59943 if test "x$path" != "x$new_path"; then
59961 59944 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
59962 59945 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
59963 59946 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
59964 59947 fi
59965 59948
59966 59949 # Save the first 10 bytes of this path to the storage, so fixpath can work.
59967 59950 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
59968 59951
59969 59952 else
59970 59953 # We're on a unix platform. Hooray! :)
59971 59954 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
59972 59955 has_space=`$ECHO "$path" | $GREP " "`
59973 59956 if test "x$has_space" != x; then
59974 59957 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
59975 59958 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
59976 59959 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
59977 59960 fi
59978 59961
59979 59962 # Use eval to expand a potential ~
59980 59963 eval path="$path"
59981 59964 if test ! -f "$path" && test ! -d "$path"; then
59982 59965 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
59983 59966 fi
59984 59967
59985 59968 if test -d "$path"; then
59986 59969 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
59987 59970 else
59988 59971 dir="`$DIRNAME "$path"`"
59989 59972 base="`$BASENAME "$path"`"
59990 59973 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
59991 59974 fi
59992 59975 fi
59993 59976 fi
59994 59977
59995 59978
59996 59979 # Only process if variable expands to non-empty
59997 59980
59998 59981 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
59999 59982 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60000 59983
60001 59984 # Input might be given as Windows format, start by converting to
60002 59985 # unix format.
60003 59986 path="$POTENTIAL_FREETYPE_LIB_PATH"
60004 59987 new_path=`$CYGPATH -u "$path"`
60005 59988
60006 59989 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60007 59990 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60008 59991 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60009 59992 # "foo.exe" is OK but "foo" is an error.
60010 59993 #
60011 59994 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60012 59995 # It is also a way to make sure we got the proper file name for the real test later on.
60013 59996 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60014 59997 if test "x$test_shortpath" = x; then
60015 59998 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60016 59999 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60017 60000 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
60018 60001 fi
60019 60002
60020 60003 # Call helper function which possibly converts this using DOS-style short mode.
60021 60004 # If so, the updated path is stored in $new_path.
60022 60005
60023 60006 input_path="$new_path"
60024 60007 # Check if we need to convert this using DOS-style short mode. If the path
60025 60008 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60026 60009 # take no chances and rewrite it.
60027 60010 # Note: m4 eats our [], so we need to use [ and ] instead.
60028 60011 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60029 60012 if test "x$has_forbidden_chars" != x; then
60030 60013 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60031 60014 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60032 60015 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60033 60016 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60034 60017 # Going to short mode and back again did indeed matter. Since short mode is
60035 60018 # case insensitive, let's make it lowercase to improve readability.
60036 60019 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60037 60020 # Now convert it back to Unix-style (cygpath)
60038 60021 input_path=`$CYGPATH -u "$shortmode_path"`
60039 60022 new_path="$input_path"
60040 60023 fi
60041 60024 fi
60042 60025
60043 60026 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60044 60027 if test "x$test_cygdrive_prefix" = x; then
60045 60028 # As a simple fix, exclude /usr/bin since it's not a real path.
60046 60029 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60047 60030 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60048 60031 # a path prefixed by /cygdrive for fixpath to work.
60049 60032 new_path="$CYGWIN_ROOT_PATH$input_path"
60050 60033 fi
60051 60034 fi
60052 60035
60053 60036
60054 60037 if test "x$path" != "x$new_path"; then
60055 60038 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60056 60039 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60057 60040 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60058 60041 fi
60059 60042
60060 60043 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60061 60044
60062 60045 path="$POTENTIAL_FREETYPE_LIB_PATH"
60063 60046 has_colon=`$ECHO $path | $GREP ^.:`
60064 60047 new_path="$path"
60065 60048 if test "x$has_colon" = x; then
60066 60049 # Not in mixed or Windows style, start by that.
60067 60050 new_path=`cmd //c echo $path`
60068 60051 fi
60069 60052
60070 60053
60071 60054 input_path="$new_path"
60072 60055 # Check if we need to convert this using DOS-style short mode. If the path
60073 60056 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60074 60057 # take no chances and rewrite it.
60075 60058 # Note: m4 eats our [], so we need to use [ and ] instead.
60076 60059 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60077 60060 if test "x$has_forbidden_chars" != x; then
60078 60061 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60079 60062 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60080 60063 fi
60081 60064
60082 60065
60083 60066 windows_path="$new_path"
60084 60067 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60085 60068 unix_path=`$CYGPATH -u "$windows_path"`
60086 60069 new_path="$unix_path"
60087 60070 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60088 60071 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60089 60072 new_path="$unix_path"
60090 60073 fi
60091 60074
60092 60075 if test "x$path" != "x$new_path"; then
60093 60076 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60094 60077 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60095 60078 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60096 60079 fi
60097 60080
60098 60081 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60099 60082 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60100 60083
60101 60084 else
60102 60085 # We're on a unix platform. Hooray! :)
60103 60086 path="$POTENTIAL_FREETYPE_LIB_PATH"
60104 60087 has_space=`$ECHO "$path" | $GREP " "`
60105 60088 if test "x$has_space" != x; then
60106 60089 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60107 60090 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60108 60091 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60109 60092 fi
60110 60093
60111 60094 # Use eval to expand a potential ~
60112 60095 eval path="$path"
60113 60096 if test ! -f "$path" && test ! -d "$path"; then
60114 60097 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
60115 60098 fi
60116 60099
60117 60100 if test -d "$path"; then
60118 60101 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
60119 60102 else
60120 60103 dir="`$DIRNAME "$path"`"
60121 60104 base="`$BASENAME "$path"`"
60122 60105 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
60123 60106 fi
60124 60107 fi
60125 60108 fi
60126 60109
60127 60110
60128 60111 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60129 60112 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
60130 60113 $as_echo_n "checking for freetype includes... " >&6; }
60131 60114 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
60132 60115 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
60133 60116 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
60134 60117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
60135 60118 $as_echo_n "checking for freetype libraries... " >&6; }
60136 60119 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
60137 60120 $as_echo "$FREETYPE_LIB_PATH" >&6; }
60138 60121 fi
60139 60122
60140 60123 fi
60141 60124 fi
60142 60125 fi
60143 60126 else
60144 60127 FREETYPE_BASE_DIR="$SYSROOT/usr"
60145 60128
60146 60129 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
60147 60130 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
60148 60131 METHOD="well-known location"
60149 60132
60150 60133 # Let's start with an optimistic view of the world :-)
60151 60134 FOUND_FREETYPE=yes
60152 60135
60153 60136 # First look for the canonical freetype main include file ft2build.h.
60154 60137 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60155 60138 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
60156 60139 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
60157 60140 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60158 60141 # Fail.
60159 60142 FOUND_FREETYPE=no
60160 60143 fi
60161 60144 fi
60162 60145
60163 60146 if test "x$FOUND_FREETYPE" = xyes; then
60164 60147 # Include file found, let's continue the sanity check.
60165 60148 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
60166 60149 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
60167 60150
60168 60151 # Reset to default value
60169 60152 FREETYPE_BASE_NAME=freetype
60170 60153 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60171 60154 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
60172 60155 if test "x$OPENJDK_TARGET_OS" = xmacosx \
60173 60156 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
60174 60157 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
60175 60158 # for the .6 version explicitly.
60176 60159 FREETYPE_BASE_NAME=freetype.6
60177 60160 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60178 60161 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
60179 60162 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
60180 60163 else
60181 60164 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
60182 60165 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
60183 60166 FOUND_FREETYPE=no
60184 60167 fi
60185 60168 else
60186 60169 if test "x$OPENJDK_TARGET_OS" = xwindows; then
60187 60170 # On Windows, we will need both .lib and .dll file.
60188 60171 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
60189 60172 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
60190 60173 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
60191 60174 FOUND_FREETYPE=no
60192 60175 fi
60193 60176 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
60194 60177 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
60195 60178 # Found lib in isa dir, use that instead.
60196 60179 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
60197 60180 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
60198 60181 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
60199 60182 fi
60200 60183 fi
60201 60184 fi
60202 60185
60203 60186 if test "x$FOUND_FREETYPE" = xyes; then
60204 60187
60205 60188 # Only process if variable expands to non-empty
60206 60189
60207 60190 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
60208 60191 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60209 60192
60210 60193 # Input might be given as Windows format, start by converting to
60211 60194 # unix format.
60212 60195 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60213 60196 new_path=`$CYGPATH -u "$path"`
60214 60197
60215 60198 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60216 60199 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60217 60200 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60218 60201 # "foo.exe" is OK but "foo" is an error.
60219 60202 #
60220 60203 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60221 60204 # It is also a way to make sure we got the proper file name for the real test later on.
60222 60205 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60223 60206 if test "x$test_shortpath" = x; then
60224 60207 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60225 60208 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60226 60209 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
60227 60210 fi
60228 60211
60229 60212 # Call helper function which possibly converts this using DOS-style short mode.
60230 60213 # If so, the updated path is stored in $new_path.
60231 60214
60232 60215 input_path="$new_path"
60233 60216 # Check if we need to convert this using DOS-style short mode. If the path
60234 60217 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60235 60218 # take no chances and rewrite it.
60236 60219 # Note: m4 eats our [], so we need to use [ and ] instead.
60237 60220 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60238 60221 if test "x$has_forbidden_chars" != x; then
60239 60222 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60240 60223 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60241 60224 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60242 60225 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60243 60226 # Going to short mode and back again did indeed matter. Since short mode is
60244 60227 # case insensitive, let's make it lowercase to improve readability.
60245 60228 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60246 60229 # Now convert it back to Unix-style (cygpath)
60247 60230 input_path=`$CYGPATH -u "$shortmode_path"`
60248 60231 new_path="$input_path"
60249 60232 fi
60250 60233 fi
60251 60234
60252 60235 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60253 60236 if test "x$test_cygdrive_prefix" = x; then
60254 60237 # As a simple fix, exclude /usr/bin since it's not a real path.
60255 60238 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60256 60239 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60257 60240 # a path prefixed by /cygdrive for fixpath to work.
60258 60241 new_path="$CYGWIN_ROOT_PATH$input_path"
60259 60242 fi
60260 60243 fi
60261 60244
60262 60245
60263 60246 if test "x$path" != "x$new_path"; then
60264 60247 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60265 60248 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60266 60249 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60267 60250 fi
60268 60251
60269 60252 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60270 60253
60271 60254 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60272 60255 has_colon=`$ECHO $path | $GREP ^.:`
60273 60256 new_path="$path"
60274 60257 if test "x$has_colon" = x; then
60275 60258 # Not in mixed or Windows style, start by that.
60276 60259 new_path=`cmd //c echo $path`
60277 60260 fi
60278 60261
60279 60262
60280 60263 input_path="$new_path"
60281 60264 # Check if we need to convert this using DOS-style short mode. If the path
60282 60265 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60283 60266 # take no chances and rewrite it.
60284 60267 # Note: m4 eats our [], so we need to use [ and ] instead.
60285 60268 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60286 60269 if test "x$has_forbidden_chars" != x; then
60287 60270 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60288 60271 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60289 60272 fi
60290 60273
60291 60274
60292 60275 windows_path="$new_path"
60293 60276 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60294 60277 unix_path=`$CYGPATH -u "$windows_path"`
60295 60278 new_path="$unix_path"
60296 60279 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60297 60280 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60298 60281 new_path="$unix_path"
60299 60282 fi
60300 60283
60301 60284 if test "x$path" != "x$new_path"; then
60302 60285 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60303 60286 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60304 60287 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60305 60288 fi
60306 60289
60307 60290 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60308 60291 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60309 60292
60310 60293 else
60311 60294 # We're on a unix platform. Hooray! :)
60312 60295 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60313 60296 has_space=`$ECHO "$path" | $GREP " "`
60314 60297 if test "x$has_space" != x; then
60315 60298 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60316 60299 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60317 60300 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60318 60301 fi
60319 60302
60320 60303 # Use eval to expand a potential ~
60321 60304 eval path="$path"
60322 60305 if test ! -f "$path" && test ! -d "$path"; then
60323 60306 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
60324 60307 fi
60325 60308
60326 60309 if test -d "$path"; then
60327 60310 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
60328 60311 else
60329 60312 dir="`$DIRNAME "$path"`"
60330 60313 base="`$BASENAME "$path"`"
60331 60314 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
60332 60315 fi
60333 60316 fi
60334 60317 fi
60335 60318
60336 60319
60337 60320 # Only process if variable expands to non-empty
60338 60321
60339 60322 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
60340 60323 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60341 60324
60342 60325 # Input might be given as Windows format, start by converting to
60343 60326 # unix format.
60344 60327 path="$POTENTIAL_FREETYPE_LIB_PATH"
60345 60328 new_path=`$CYGPATH -u "$path"`
60346 60329
60347 60330 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60348 60331 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60349 60332 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60350 60333 # "foo.exe" is OK but "foo" is an error.
60351 60334 #
60352 60335 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60353 60336 # It is also a way to make sure we got the proper file name for the real test later on.
60354 60337 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60355 60338 if test "x$test_shortpath" = x; then
60356 60339 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60357 60340 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60358 60341 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
60359 60342 fi
60360 60343
60361 60344 # Call helper function which possibly converts this using DOS-style short mode.
60362 60345 # If so, the updated path is stored in $new_path.
60363 60346
60364 60347 input_path="$new_path"
60365 60348 # Check if we need to convert this using DOS-style short mode. If the path
60366 60349 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60367 60350 # take no chances and rewrite it.
60368 60351 # Note: m4 eats our [], so we need to use [ and ] instead.
60369 60352 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60370 60353 if test "x$has_forbidden_chars" != x; then
60371 60354 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60372 60355 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60373 60356 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60374 60357 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60375 60358 # Going to short mode and back again did indeed matter. Since short mode is
60376 60359 # case insensitive, let's make it lowercase to improve readability.
60377 60360 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60378 60361 # Now convert it back to Unix-style (cygpath)
60379 60362 input_path=`$CYGPATH -u "$shortmode_path"`
60380 60363 new_path="$input_path"
60381 60364 fi
60382 60365 fi
60383 60366
60384 60367 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60385 60368 if test "x$test_cygdrive_prefix" = x; then
60386 60369 # As a simple fix, exclude /usr/bin since it's not a real path.
60387 60370 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60388 60371 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60389 60372 # a path prefixed by /cygdrive for fixpath to work.
60390 60373 new_path="$CYGWIN_ROOT_PATH$input_path"
60391 60374 fi
60392 60375 fi
60393 60376
60394 60377
60395 60378 if test "x$path" != "x$new_path"; then
60396 60379 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60397 60380 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60398 60381 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60399 60382 fi
60400 60383
60401 60384 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60402 60385
60403 60386 path="$POTENTIAL_FREETYPE_LIB_PATH"
60404 60387 has_colon=`$ECHO $path | $GREP ^.:`
60405 60388 new_path="$path"
60406 60389 if test "x$has_colon" = x; then
60407 60390 # Not in mixed or Windows style, start by that.
60408 60391 new_path=`cmd //c echo $path`
60409 60392 fi
60410 60393
60411 60394
60412 60395 input_path="$new_path"
60413 60396 # Check if we need to convert this using DOS-style short mode. If the path
60414 60397 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60415 60398 # take no chances and rewrite it.
60416 60399 # Note: m4 eats our [], so we need to use [ and ] instead.
60417 60400 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60418 60401 if test "x$has_forbidden_chars" != x; then
60419 60402 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60420 60403 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60421 60404 fi
60422 60405
60423 60406
60424 60407 windows_path="$new_path"
60425 60408 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60426 60409 unix_path=`$CYGPATH -u "$windows_path"`
60427 60410 new_path="$unix_path"
60428 60411 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60429 60412 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60430 60413 new_path="$unix_path"
60431 60414 fi
60432 60415
60433 60416 if test "x$path" != "x$new_path"; then
60434 60417 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60435 60418 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60436 60419 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60437 60420 fi
60438 60421
60439 60422 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60440 60423 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60441 60424
60442 60425 else
60443 60426 # We're on a unix platform. Hooray! :)
60444 60427 path="$POTENTIAL_FREETYPE_LIB_PATH"
60445 60428 has_space=`$ECHO "$path" | $GREP " "`
60446 60429 if test "x$has_space" != x; then
60447 60430 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60448 60431 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60449 60432 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60450 60433 fi
60451 60434
60452 60435 # Use eval to expand a potential ~
60453 60436 eval path="$path"
60454 60437 if test ! -f "$path" && test ! -d "$path"; then
60455 60438 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
60456 60439 fi
60457 60440
60458 60441 if test -d "$path"; then
60459 60442 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
60460 60443 else
60461 60444 dir="`$DIRNAME "$path"`"
60462 60445 base="`$BASENAME "$path"`"
60463 60446 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
60464 60447 fi
60465 60448 fi
60466 60449 fi
60467 60450
60468 60451
60469 60452 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60470 60453 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
60471 60454 $as_echo_n "checking for freetype includes... " >&6; }
60472 60455 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
60473 60456 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
60474 60457 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
60475 60458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
60476 60459 $as_echo_n "checking for freetype libraries... " >&6; }
60477 60460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
60478 60461 $as_echo "$FREETYPE_LIB_PATH" >&6; }
60479 60462 fi
60480 60463
60481 60464
60482 60465 if test "x$FOUND_FREETYPE" != xyes; then
60483 60466 FREETYPE_BASE_DIR="$SYSROOT/usr/X11"
60484 60467
60485 60468 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
60486 60469 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
60487 60470 METHOD="well-known location"
60488 60471
60489 60472 # Let's start with an optimistic view of the world :-)
60490 60473 FOUND_FREETYPE=yes
60491 60474
60492 60475 # First look for the canonical freetype main include file ft2build.h.
60493 60476 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60494 60477 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
60495 60478 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
60496 60479 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60497 60480 # Fail.
60498 60481 FOUND_FREETYPE=no
60499 60482 fi
60500 60483 fi
60501 60484
60502 60485 if test "x$FOUND_FREETYPE" = xyes; then
60503 60486 # Include file found, let's continue the sanity check.
60504 60487 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
60505 60488 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
60506 60489
60507 60490 # Reset to default value
60508 60491 FREETYPE_BASE_NAME=freetype
60509 60492 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60510 60493 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
60511 60494 if test "x$OPENJDK_TARGET_OS" = xmacosx \
60512 60495 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
60513 60496 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
60514 60497 # for the .6 version explicitly.
60515 60498 FREETYPE_BASE_NAME=freetype.6
60516 60499 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60517 60500 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
60518 60501 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
60519 60502 else
60520 60503 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
60521 60504 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
60522 60505 FOUND_FREETYPE=no
60523 60506 fi
60524 60507 else
60525 60508 if test "x$OPENJDK_TARGET_OS" = xwindows; then
60526 60509 # On Windows, we will need both .lib and .dll file.
60527 60510 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
60528 60511 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
60529 60512 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
60530 60513 FOUND_FREETYPE=no
60531 60514 fi
60532 60515 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
60533 60516 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
60534 60517 # Found lib in isa dir, use that instead.
60535 60518 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
60536 60519 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
60537 60520 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
60538 60521 fi
60539 60522 fi
60540 60523 fi
60541 60524
60542 60525 if test "x$FOUND_FREETYPE" = xyes; then
60543 60526
60544 60527 # Only process if variable expands to non-empty
60545 60528
60546 60529 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
60547 60530 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60548 60531
60549 60532 # Input might be given as Windows format, start by converting to
60550 60533 # unix format.
60551 60534 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60552 60535 new_path=`$CYGPATH -u "$path"`
60553 60536
60554 60537 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60555 60538 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60556 60539 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60557 60540 # "foo.exe" is OK but "foo" is an error.
60558 60541 #
60559 60542 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60560 60543 # It is also a way to make sure we got the proper file name for the real test later on.
60561 60544 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60562 60545 if test "x$test_shortpath" = x; then
60563 60546 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60564 60547 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60565 60548 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
60566 60549 fi
60567 60550
60568 60551 # Call helper function which possibly converts this using DOS-style short mode.
60569 60552 # If so, the updated path is stored in $new_path.
60570 60553
60571 60554 input_path="$new_path"
60572 60555 # Check if we need to convert this using DOS-style short mode. If the path
60573 60556 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60574 60557 # take no chances and rewrite it.
60575 60558 # Note: m4 eats our [], so we need to use [ and ] instead.
60576 60559 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60577 60560 if test "x$has_forbidden_chars" != x; then
60578 60561 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60579 60562 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60580 60563 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60581 60564 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60582 60565 # Going to short mode and back again did indeed matter. Since short mode is
60583 60566 # case insensitive, let's make it lowercase to improve readability.
60584 60567 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60585 60568 # Now convert it back to Unix-style (cygpath)
60586 60569 input_path=`$CYGPATH -u "$shortmode_path"`
60587 60570 new_path="$input_path"
60588 60571 fi
60589 60572 fi
60590 60573
60591 60574 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60592 60575 if test "x$test_cygdrive_prefix" = x; then
60593 60576 # As a simple fix, exclude /usr/bin since it's not a real path.
60594 60577 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60595 60578 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60596 60579 # a path prefixed by /cygdrive for fixpath to work.
60597 60580 new_path="$CYGWIN_ROOT_PATH$input_path"
60598 60581 fi
60599 60582 fi
60600 60583
60601 60584
60602 60585 if test "x$path" != "x$new_path"; then
60603 60586 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60604 60587 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60605 60588 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60606 60589 fi
60607 60590
60608 60591 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60609 60592
60610 60593 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60611 60594 has_colon=`$ECHO $path | $GREP ^.:`
60612 60595 new_path="$path"
60613 60596 if test "x$has_colon" = x; then
60614 60597 # Not in mixed or Windows style, start by that.
60615 60598 new_path=`cmd //c echo $path`
60616 60599 fi
60617 60600
60618 60601
60619 60602 input_path="$new_path"
60620 60603 # Check if we need to convert this using DOS-style short mode. If the path
60621 60604 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60622 60605 # take no chances and rewrite it.
60623 60606 # Note: m4 eats our [], so we need to use [ and ] instead.
60624 60607 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60625 60608 if test "x$has_forbidden_chars" != x; then
60626 60609 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60627 60610 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60628 60611 fi
60629 60612
60630 60613
60631 60614 windows_path="$new_path"
60632 60615 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60633 60616 unix_path=`$CYGPATH -u "$windows_path"`
60634 60617 new_path="$unix_path"
60635 60618 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60636 60619 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60637 60620 new_path="$unix_path"
60638 60621 fi
60639 60622
60640 60623 if test "x$path" != "x$new_path"; then
60641 60624 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60642 60625 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60643 60626 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60644 60627 fi
60645 60628
60646 60629 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60647 60630 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60648 60631
60649 60632 else
60650 60633 # We're on a unix platform. Hooray! :)
60651 60634 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60652 60635 has_space=`$ECHO "$path" | $GREP " "`
60653 60636 if test "x$has_space" != x; then
60654 60637 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60655 60638 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60656 60639 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60657 60640 fi
60658 60641
60659 60642 # Use eval to expand a potential ~
60660 60643 eval path="$path"
60661 60644 if test ! -f "$path" && test ! -d "$path"; then
60662 60645 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
60663 60646 fi
60664 60647
60665 60648 if test -d "$path"; then
60666 60649 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
60667 60650 else
60668 60651 dir="`$DIRNAME "$path"`"
60669 60652 base="`$BASENAME "$path"`"
60670 60653 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
60671 60654 fi
60672 60655 fi
60673 60656 fi
60674 60657
60675 60658
60676 60659 # Only process if variable expands to non-empty
60677 60660
60678 60661 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
60679 60662 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60680 60663
60681 60664 # Input might be given as Windows format, start by converting to
60682 60665 # unix format.
60683 60666 path="$POTENTIAL_FREETYPE_LIB_PATH"
60684 60667 new_path=`$CYGPATH -u "$path"`
60685 60668
60686 60669 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60687 60670 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60688 60671 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60689 60672 # "foo.exe" is OK but "foo" is an error.
60690 60673 #
60691 60674 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60692 60675 # It is also a way to make sure we got the proper file name for the real test later on.
60693 60676 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60694 60677 if test "x$test_shortpath" = x; then
60695 60678 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60696 60679 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60697 60680 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
60698 60681 fi
60699 60682
60700 60683 # Call helper function which possibly converts this using DOS-style short mode.
60701 60684 # If so, the updated path is stored in $new_path.
60702 60685
60703 60686 input_path="$new_path"
60704 60687 # Check if we need to convert this using DOS-style short mode. If the path
60705 60688 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60706 60689 # take no chances and rewrite it.
60707 60690 # Note: m4 eats our [], so we need to use [ and ] instead.
60708 60691 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60709 60692 if test "x$has_forbidden_chars" != x; then
60710 60693 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60711 60694 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60712 60695 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60713 60696 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60714 60697 # Going to short mode and back again did indeed matter. Since short mode is
60715 60698 # case insensitive, let's make it lowercase to improve readability.
60716 60699 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60717 60700 # Now convert it back to Unix-style (cygpath)
60718 60701 input_path=`$CYGPATH -u "$shortmode_path"`
60719 60702 new_path="$input_path"
60720 60703 fi
60721 60704 fi
60722 60705
60723 60706 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60724 60707 if test "x$test_cygdrive_prefix" = x; then
60725 60708 # As a simple fix, exclude /usr/bin since it's not a real path.
60726 60709 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60727 60710 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60728 60711 # a path prefixed by /cygdrive for fixpath to work.
60729 60712 new_path="$CYGWIN_ROOT_PATH$input_path"
60730 60713 fi
60731 60714 fi
60732 60715
60733 60716
60734 60717 if test "x$path" != "x$new_path"; then
60735 60718 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60736 60719 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60737 60720 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60738 60721 fi
60739 60722
60740 60723 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60741 60724
60742 60725 path="$POTENTIAL_FREETYPE_LIB_PATH"
60743 60726 has_colon=`$ECHO $path | $GREP ^.:`
60744 60727 new_path="$path"
60745 60728 if test "x$has_colon" = x; then
60746 60729 # Not in mixed or Windows style, start by that.
60747 60730 new_path=`cmd //c echo $path`
60748 60731 fi
60749 60732
60750 60733
60751 60734 input_path="$new_path"
60752 60735 # Check if we need to convert this using DOS-style short mode. If the path
60753 60736 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60754 60737 # take no chances and rewrite it.
60755 60738 # Note: m4 eats our [], so we need to use [ and ] instead.
60756 60739 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60757 60740 if test "x$has_forbidden_chars" != x; then
60758 60741 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60759 60742 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60760 60743 fi
60761 60744
60762 60745
60763 60746 windows_path="$new_path"
60764 60747 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60765 60748 unix_path=`$CYGPATH -u "$windows_path"`
60766 60749 new_path="$unix_path"
60767 60750 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60768 60751 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60769 60752 new_path="$unix_path"
60770 60753 fi
60771 60754
60772 60755 if test "x$path" != "x$new_path"; then
60773 60756 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
60774 60757 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
60775 60758 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
60776 60759 fi
60777 60760
60778 60761 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60779 60762 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60780 60763
60781 60764 else
60782 60765 # We're on a unix platform. Hooray! :)
60783 60766 path="$POTENTIAL_FREETYPE_LIB_PATH"
60784 60767 has_space=`$ECHO "$path" | $GREP " "`
60785 60768 if test "x$has_space" != x; then
60786 60769 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
60787 60770 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
60788 60771 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60789 60772 fi
60790 60773
60791 60774 # Use eval to expand a potential ~
60792 60775 eval path="$path"
60793 60776 if test ! -f "$path" && test ! -d "$path"; then
60794 60777 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
60795 60778 fi
60796 60779
60797 60780 if test -d "$path"; then
60798 60781 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
60799 60782 else
60800 60783 dir="`$DIRNAME "$path"`"
60801 60784 base="`$BASENAME "$path"`"
60802 60785 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
60803 60786 fi
60804 60787 fi
60805 60788 fi
60806 60789
60807 60790
60808 60791 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60809 60792 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
60810 60793 $as_echo_n "checking for freetype includes... " >&6; }
60811 60794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
60812 60795 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
60813 60796 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
60814 60797 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
60815 60798 $as_echo_n "checking for freetype libraries... " >&6; }
60816 60799 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
60817 60800 $as_echo "$FREETYPE_LIB_PATH" >&6; }
60818 60801 fi
60819 60802
60820 60803 fi
60821 60804
60822 60805 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
60823 60806 if test "x$FOUND_FREETYPE" != xyes; then
60824 60807 # Due to changes in OSX 10.11 XQuartz now installs to /opt/X11
60825 60808 FREETYPE_BASE_DIR="$SYSROOT/opt/X11"
60826 60809
60827 60810 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
60828 60811 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
60829 60812 METHOD="well-known location"
60830 60813
60831 60814 # Let's start with an optimistic view of the world :-)
60832 60815 FOUND_FREETYPE=yes
60833 60816
60834 60817 # First look for the canonical freetype main include file ft2build.h.
60835 60818 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60836 60819 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
60837 60820 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
60838 60821 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
60839 60822 # Fail.
60840 60823 FOUND_FREETYPE=no
60841 60824 fi
60842 60825 fi
60843 60826
60844 60827 if test "x$FOUND_FREETYPE" = xyes; then
60845 60828 # Include file found, let's continue the sanity check.
60846 60829 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
60847 60830 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
60848 60831
60849 60832 # Reset to default value
60850 60833 FREETYPE_BASE_NAME=freetype
60851 60834 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60852 60835 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
60853 60836 if test "x$OPENJDK_TARGET_OS" = xmacosx \
60854 60837 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
60855 60838 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
60856 60839 # for the .6 version explicitly.
60857 60840 FREETYPE_BASE_NAME=freetype.6
60858 60841 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
60859 60842 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
60860 60843 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
60861 60844 else
60862 60845 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
60863 60846 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
60864 60847 FOUND_FREETYPE=no
60865 60848 fi
60866 60849 else
60867 60850 if test "x$OPENJDK_TARGET_OS" = xwindows; then
60868 60851 # On Windows, we will need both .lib and .dll file.
60869 60852 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
60870 60853 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
60871 60854 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
60872 60855 FOUND_FREETYPE=no
60873 60856 fi
60874 60857 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
60875 60858 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
60876 60859 # Found lib in isa dir, use that instead.
60877 60860 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
60878 60861 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
60879 60862 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
60880 60863 fi
60881 60864 fi
60882 60865 fi
60883 60866
60884 60867 if test "x$FOUND_FREETYPE" = xyes; then
60885 60868
60886 60869 # Only process if variable expands to non-empty
60887 60870
60888 60871 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
60889 60872 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60890 60873
60891 60874 # Input might be given as Windows format, start by converting to
60892 60875 # unix format.
60893 60876 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60894 60877 new_path=`$CYGPATH -u "$path"`
60895 60878
60896 60879 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
60897 60880 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
60898 60881 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
60899 60882 # "foo.exe" is OK but "foo" is an error.
60900 60883 #
60901 60884 # This test is therefore slightly more accurate than "test -f" to check for file precense.
60902 60885 # It is also a way to make sure we got the proper file name for the real test later on.
60903 60886 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
60904 60887 if test "x$test_shortpath" = x; then
60905 60888 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60906 60889 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60907 60890 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
60908 60891 fi
60909 60892
60910 60893 # Call helper function which possibly converts this using DOS-style short mode.
60911 60894 # If so, the updated path is stored in $new_path.
60912 60895
60913 60896 input_path="$new_path"
60914 60897 # Check if we need to convert this using DOS-style short mode. If the path
60915 60898 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60916 60899 # take no chances and rewrite it.
60917 60900 # Note: m4 eats our [], so we need to use [ and ] instead.
60918 60901 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
60919 60902 if test "x$has_forbidden_chars" != x; then
60920 60903 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60921 60904 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
60922 60905 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
60923 60906 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
60924 60907 # Going to short mode and back again did indeed matter. Since short mode is
60925 60908 # case insensitive, let's make it lowercase to improve readability.
60926 60909 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60927 60910 # Now convert it back to Unix-style (cygpath)
60928 60911 input_path=`$CYGPATH -u "$shortmode_path"`
60929 60912 new_path="$input_path"
60930 60913 fi
60931 60914 fi
60932 60915
60933 60916 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
60934 60917 if test "x$test_cygdrive_prefix" = x; then
60935 60918 # As a simple fix, exclude /usr/bin since it's not a real path.
60936 60919 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
60937 60920 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
60938 60921 # a path prefixed by /cygdrive for fixpath to work.
60939 60922 new_path="$CYGWIN_ROOT_PATH$input_path"
60940 60923 fi
60941 60924 fi
60942 60925
60943 60926
60944 60927 if test "x$path" != "x$new_path"; then
60945 60928 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60946 60929 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60947 60930 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60948 60931 fi
60949 60932
60950 60933 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60951 60934
60952 60935 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60953 60936 has_colon=`$ECHO $path | $GREP ^.:`
60954 60937 new_path="$path"
60955 60938 if test "x$has_colon" = x; then
60956 60939 # Not in mixed or Windows style, start by that.
60957 60940 new_path=`cmd //c echo $path`
60958 60941 fi
60959 60942
60960 60943
60961 60944 input_path="$new_path"
60962 60945 # Check if we need to convert this using DOS-style short mode. If the path
60963 60946 # contains just simple characters, use it. Otherwise (spaces, weird characters),
60964 60947 # take no chances and rewrite it.
60965 60948 # Note: m4 eats our [], so we need to use [ and ] instead.
60966 60949 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
60967 60950 if test "x$has_forbidden_chars" != x; then
60968 60951 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
60969 60952 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
60970 60953 fi
60971 60954
60972 60955
60973 60956 windows_path="$new_path"
60974 60957 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
60975 60958 unix_path=`$CYGPATH -u "$windows_path"`
60976 60959 new_path="$unix_path"
60977 60960 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
60978 60961 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
60979 60962 new_path="$unix_path"
60980 60963 fi
60981 60964
60982 60965 if test "x$path" != "x$new_path"; then
60983 60966 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
60984 60967 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
60985 60968 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
60986 60969 fi
60987 60970
60988 60971 # Save the first 10 bytes of this path to the storage, so fixpath can work.
60989 60972 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
60990 60973
60991 60974 else
60992 60975 # We're on a unix platform. Hooray! :)
60993 60976 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
60994 60977 has_space=`$ECHO "$path" | $GREP " "`
60995 60978 if test "x$has_space" != x; then
60996 60979 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
60997 60980 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
60998 60981 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
60999 60982 fi
61000 60983
61001 60984 # Use eval to expand a potential ~
61002 60985 eval path="$path"
61003 60986 if test ! -f "$path" && test ! -d "$path"; then
61004 60987 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61005 60988 fi
61006 60989
61007 60990 if test -d "$path"; then
61008 60991 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
61009 60992 else
61010 60993 dir="`$DIRNAME "$path"`"
61011 60994 base="`$BASENAME "$path"`"
61012 60995 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61013 60996 fi
61014 60997 fi
61015 60998 fi
61016 60999
61017 61000
61018 61001 # Only process if variable expands to non-empty
61019 61002
61020 61003 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
61021 61004 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61022 61005
61023 61006 # Input might be given as Windows format, start by converting to
61024 61007 # unix format.
61025 61008 path="$POTENTIAL_FREETYPE_LIB_PATH"
61026 61009 new_path=`$CYGPATH -u "$path"`
61027 61010
61028 61011 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61029 61012 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61030 61013 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61031 61014 # "foo.exe" is OK but "foo" is an error.
61032 61015 #
61033 61016 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61034 61017 # It is also a way to make sure we got the proper file name for the real test later on.
61035 61018 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61036 61019 if test "x$test_shortpath" = x; then
61037 61020 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61038 61021 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61039 61022 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
61040 61023 fi
61041 61024
61042 61025 # Call helper function which possibly converts this using DOS-style short mode.
61043 61026 # If so, the updated path is stored in $new_path.
61044 61027
61045 61028 input_path="$new_path"
61046 61029 # Check if we need to convert this using DOS-style short mode. If the path
61047 61030 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61048 61031 # take no chances and rewrite it.
61049 61032 # Note: m4 eats our [], so we need to use [ and ] instead.
61050 61033 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61051 61034 if test "x$has_forbidden_chars" != x; then
61052 61035 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61053 61036 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61054 61037 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61055 61038 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61056 61039 # Going to short mode and back again did indeed matter. Since short mode is
61057 61040 # case insensitive, let's make it lowercase to improve readability.
61058 61041 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61059 61042 # Now convert it back to Unix-style (cygpath)
61060 61043 input_path=`$CYGPATH -u "$shortmode_path"`
61061 61044 new_path="$input_path"
61062 61045 fi
61063 61046 fi
61064 61047
61065 61048 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61066 61049 if test "x$test_cygdrive_prefix" = x; then
61067 61050 # As a simple fix, exclude /usr/bin since it's not a real path.
61068 61051 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61069 61052 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61070 61053 # a path prefixed by /cygdrive for fixpath to work.
61071 61054 new_path="$CYGWIN_ROOT_PATH$input_path"
61072 61055 fi
61073 61056 fi
61074 61057
61075 61058
61076 61059 if test "x$path" != "x$new_path"; then
61077 61060 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61078 61061 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61079 61062 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61080 61063 fi
61081 61064
61082 61065 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61083 61066
61084 61067 path="$POTENTIAL_FREETYPE_LIB_PATH"
61085 61068 has_colon=`$ECHO $path | $GREP ^.:`
61086 61069 new_path="$path"
61087 61070 if test "x$has_colon" = x; then
61088 61071 # Not in mixed or Windows style, start by that.
61089 61072 new_path=`cmd //c echo $path`
61090 61073 fi
61091 61074
61092 61075
61093 61076 input_path="$new_path"
61094 61077 # Check if we need to convert this using DOS-style short mode. If the path
61095 61078 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61096 61079 # take no chances and rewrite it.
61097 61080 # Note: m4 eats our [], so we need to use [ and ] instead.
61098 61081 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61099 61082 if test "x$has_forbidden_chars" != x; then
61100 61083 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61101 61084 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61102 61085 fi
61103 61086
61104 61087
61105 61088 windows_path="$new_path"
61106 61089 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61107 61090 unix_path=`$CYGPATH -u "$windows_path"`
61108 61091 new_path="$unix_path"
61109 61092 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61110 61093 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61111 61094 new_path="$unix_path"
61112 61095 fi
61113 61096
61114 61097 if test "x$path" != "x$new_path"; then
61115 61098 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61116 61099 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61117 61100 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61118 61101 fi
61119 61102
61120 61103 # Save the first 10 bytes of this path to the storage, so fixpath can work.
61121 61104 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
61122 61105
61123 61106 else
61124 61107 # We're on a unix platform. Hooray! :)
61125 61108 path="$POTENTIAL_FREETYPE_LIB_PATH"
61126 61109 has_space=`$ECHO "$path" | $GREP " "`
61127 61110 if test "x$has_space" != x; then
61128 61111 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61129 61112 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61130 61113 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
61131 61114 fi
61132 61115
61133 61116 # Use eval to expand a potential ~
61134 61117 eval path="$path"
61135 61118 if test ! -f "$path" && test ! -d "$path"; then
61136 61119 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61137 61120 fi
61138 61121
61139 61122 if test -d "$path"; then
61140 61123 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
61141 61124 else
61142 61125 dir="`$DIRNAME "$path"`"
61143 61126 base="`$BASENAME "$path"`"
61144 61127 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61145 61128 fi
61146 61129 fi
61147 61130 fi
61148 61131
61149 61132
61150 61133 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61151 61134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
61152 61135 $as_echo_n "checking for freetype includes... " >&6; }
61153 61136 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
61154 61137 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
61155 61138 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
61156 61139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
61157 61140 $as_echo_n "checking for freetype libraries... " >&6; }
61158 61141 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
61159 61142 $as_echo "$FREETYPE_LIB_PATH" >&6; }
61160 61143 fi
61161 61144
61162 61145 fi
61163 61146 fi
61164 61147
61165 61148 if test "x$FOUND_FREETYPE" != xyes; then
61166 61149 FREETYPE_BASE_DIR="$SYSROOT/usr/sfw"
61167 61150
61168 61151 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
61169 61152 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
61170 61153 METHOD="well-known location"
61171 61154
61172 61155 # Let's start with an optimistic view of the world :-)
61173 61156 FOUND_FREETYPE=yes
61174 61157
61175 61158 # First look for the canonical freetype main include file ft2build.h.
61176 61159 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61177 61160 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
61178 61161 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
61179 61162 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61180 61163 # Fail.
61181 61164 FOUND_FREETYPE=no
61182 61165 fi
61183 61166 fi
61184 61167
61185 61168 if test "x$FOUND_FREETYPE" = xyes; then
61186 61169 # Include file found, let's continue the sanity check.
61187 61170 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
61188 61171 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
61189 61172
61190 61173 # Reset to default value
61191 61174 FREETYPE_BASE_NAME=freetype
61192 61175 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61193 61176 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
61194 61177 if test "x$OPENJDK_TARGET_OS" = xmacosx \
61195 61178 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
61196 61179 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
61197 61180 # for the .6 version explicitly.
61198 61181 FREETYPE_BASE_NAME=freetype.6
61199 61182 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61200 61183 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
61201 61184 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
61202 61185 else
61203 61186 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
61204 61187 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
61205 61188 FOUND_FREETYPE=no
61206 61189 fi
61207 61190 else
61208 61191 if test "x$OPENJDK_TARGET_OS" = xwindows; then
61209 61192 # On Windows, we will need both .lib and .dll file.
61210 61193 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
61211 61194 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
61212 61195 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
61213 61196 FOUND_FREETYPE=no
61214 61197 fi
61215 61198 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
61216 61199 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
61217 61200 # Found lib in isa dir, use that instead.
61218 61201 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
61219 61202 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
61220 61203 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
61221 61204 fi
61222 61205 fi
61223 61206 fi
61224 61207
61225 61208 if test "x$FOUND_FREETYPE" = xyes; then
61226 61209
61227 61210 # Only process if variable expands to non-empty
61228 61211
61229 61212 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
61230 61213 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61231 61214
61232 61215 # Input might be given as Windows format, start by converting to
61233 61216 # unix format.
61234 61217 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61235 61218 new_path=`$CYGPATH -u "$path"`
61236 61219
61237 61220 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61238 61221 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61239 61222 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61240 61223 # "foo.exe" is OK but "foo" is an error.
61241 61224 #
61242 61225 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61243 61226 # It is also a way to make sure we got the proper file name for the real test later on.
61244 61227 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61245 61228 if test "x$test_shortpath" = x; then
61246 61229 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
61247 61230 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
61248 61231 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
61249 61232 fi
61250 61233
61251 61234 # Call helper function which possibly converts this using DOS-style short mode.
61252 61235 # If so, the updated path is stored in $new_path.
61253 61236
61254 61237 input_path="$new_path"
61255 61238 # Check if we need to convert this using DOS-style short mode. If the path
61256 61239 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61257 61240 # take no chances and rewrite it.
61258 61241 # Note: m4 eats our [], so we need to use [ and ] instead.
61259 61242 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61260 61243 if test "x$has_forbidden_chars" != x; then
61261 61244 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61262 61245 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61263 61246 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61264 61247 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61265 61248 # Going to short mode and back again did indeed matter. Since short mode is
61266 61249 # case insensitive, let's make it lowercase to improve readability.
61267 61250 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61268 61251 # Now convert it back to Unix-style (cygpath)
61269 61252 input_path=`$CYGPATH -u "$shortmode_path"`
61270 61253 new_path="$input_path"
61271 61254 fi
61272 61255 fi
61273 61256
61274 61257 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61275 61258 if test "x$test_cygdrive_prefix" = x; then
61276 61259 # As a simple fix, exclude /usr/bin since it's not a real path.
61277 61260 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61278 61261 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61279 61262 # a path prefixed by /cygdrive for fixpath to work.
61280 61263 new_path="$CYGWIN_ROOT_PATH$input_path"
61281 61264 fi
61282 61265 fi
61283 61266
61284 61267
61285 61268 if test "x$path" != "x$new_path"; then
61286 61269 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
61287 61270 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
61288 61271 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
61289 61272 fi
61290 61273
61291 61274 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61292 61275
61293 61276 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61294 61277 has_colon=`$ECHO $path | $GREP ^.:`
61295 61278 new_path="$path"
61296 61279 if test "x$has_colon" = x; then
61297 61280 # Not in mixed or Windows style, start by that.
61298 61281 new_path=`cmd //c echo $path`
61299 61282 fi
61300 61283
61301 61284
61302 61285 input_path="$new_path"
61303 61286 # Check if we need to convert this using DOS-style short mode. If the path
61304 61287 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61305 61288 # take no chances and rewrite it.
61306 61289 # Note: m4 eats our [], so we need to use [ and ] instead.
61307 61290 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61308 61291 if test "x$has_forbidden_chars" != x; then
61309 61292 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61310 61293 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61311 61294 fi
61312 61295
61313 61296
61314 61297 windows_path="$new_path"
61315 61298 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61316 61299 unix_path=`$CYGPATH -u "$windows_path"`
61317 61300 new_path="$unix_path"
61318 61301 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61319 61302 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61320 61303 new_path="$unix_path"
61321 61304 fi
61322 61305
61323 61306 if test "x$path" != "x$new_path"; then
61324 61307 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
61325 61308 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
61326 61309 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
61327 61310 fi
61328 61311
61329 61312 # Save the first 10 bytes of this path to the storage, so fixpath can work.
61330 61313 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
61331 61314
61332 61315 else
61333 61316 # We're on a unix platform. Hooray! :)
61334 61317 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61335 61318 has_space=`$ECHO "$path" | $GREP " "`
61336 61319 if test "x$has_space" != x; then
61337 61320 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
61338 61321 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
61339 61322 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
61340 61323 fi
61341 61324
61342 61325 # Use eval to expand a potential ~
61343 61326 eval path="$path"
61344 61327 if test ! -f "$path" && test ! -d "$path"; then
61345 61328 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61346 61329 fi
61347 61330
61348 61331 if test -d "$path"; then
61349 61332 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
61350 61333 else
61351 61334 dir="`$DIRNAME "$path"`"
61352 61335 base="`$BASENAME "$path"`"
61353 61336 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61354 61337 fi
61355 61338 fi
61356 61339 fi
61357 61340
61358 61341
61359 61342 # Only process if variable expands to non-empty
61360 61343
61361 61344 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
61362 61345 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61363 61346
61364 61347 # Input might be given as Windows format, start by converting to
61365 61348 # unix format.
61366 61349 path="$POTENTIAL_FREETYPE_LIB_PATH"
61367 61350 new_path=`$CYGPATH -u "$path"`
61368 61351
61369 61352 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61370 61353 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61371 61354 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61372 61355 # "foo.exe" is OK but "foo" is an error.
61373 61356 #
61374 61357 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61375 61358 # It is also a way to make sure we got the proper file name for the real test later on.
61376 61359 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61377 61360 if test "x$test_shortpath" = x; then
61378 61361 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61379 61362 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61380 61363 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
61381 61364 fi
61382 61365
61383 61366 # Call helper function which possibly converts this using DOS-style short mode.
61384 61367 # If so, the updated path is stored in $new_path.
61385 61368
61386 61369 input_path="$new_path"
61387 61370 # Check if we need to convert this using DOS-style short mode. If the path
61388 61371 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61389 61372 # take no chances and rewrite it.
61390 61373 # Note: m4 eats our [], so we need to use [ and ] instead.
61391 61374 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61392 61375 if test "x$has_forbidden_chars" != x; then
61393 61376 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61394 61377 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61395 61378 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61396 61379 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61397 61380 # Going to short mode and back again did indeed matter. Since short mode is
61398 61381 # case insensitive, let's make it lowercase to improve readability.
61399 61382 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61400 61383 # Now convert it back to Unix-style (cygpath)
61401 61384 input_path=`$CYGPATH -u "$shortmode_path"`
61402 61385 new_path="$input_path"
61403 61386 fi
61404 61387 fi
61405 61388
61406 61389 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61407 61390 if test "x$test_cygdrive_prefix" = x; then
61408 61391 # As a simple fix, exclude /usr/bin since it's not a real path.
61409 61392 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61410 61393 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61411 61394 # a path prefixed by /cygdrive for fixpath to work.
61412 61395 new_path="$CYGWIN_ROOT_PATH$input_path"
61413 61396 fi
61414 61397 fi
61415 61398
61416 61399
61417 61400 if test "x$path" != "x$new_path"; then
61418 61401 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61419 61402 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61420 61403 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61421 61404 fi
61422 61405
61423 61406 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61424 61407
61425 61408 path="$POTENTIAL_FREETYPE_LIB_PATH"
61426 61409 has_colon=`$ECHO $path | $GREP ^.:`
61427 61410 new_path="$path"
61428 61411 if test "x$has_colon" = x; then
61429 61412 # Not in mixed or Windows style, start by that.
61430 61413 new_path=`cmd //c echo $path`
61431 61414 fi
61432 61415
61433 61416
61434 61417 input_path="$new_path"
61435 61418 # Check if we need to convert this using DOS-style short mode. If the path
61436 61419 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61437 61420 # take no chances and rewrite it.
61438 61421 # Note: m4 eats our [], so we need to use [ and ] instead.
61439 61422 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61440 61423 if test "x$has_forbidden_chars" != x; then
61441 61424 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61442 61425 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61443 61426 fi
61444 61427
61445 61428
61446 61429 windows_path="$new_path"
61447 61430 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61448 61431 unix_path=`$CYGPATH -u "$windows_path"`
61449 61432 new_path="$unix_path"
61450 61433 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61451 61434 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61452 61435 new_path="$unix_path"
61453 61436 fi
61454 61437
61455 61438 if test "x$path" != "x$new_path"; then
61456 61439 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61457 61440 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61458 61441 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61459 61442 fi
61460 61443
61461 61444 # Save the first 10 bytes of this path to the storage, so fixpath can work.
61462 61445 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
61463 61446
61464 61447 else
61465 61448 # We're on a unix platform. Hooray! :)
61466 61449 path="$POTENTIAL_FREETYPE_LIB_PATH"
61467 61450 has_space=`$ECHO "$path" | $GREP " "`
61468 61451 if test "x$has_space" != x; then
61469 61452 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61470 61453 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61471 61454 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
61472 61455 fi
61473 61456
61474 61457 # Use eval to expand a potential ~
61475 61458 eval path="$path"
61476 61459 if test ! -f "$path" && test ! -d "$path"; then
61477 61460 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61478 61461 fi
61479 61462
61480 61463 if test -d "$path"; then
61481 61464 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
61482 61465 else
61483 61466 dir="`$DIRNAME "$path"`"
61484 61467 base="`$BASENAME "$path"`"
61485 61468 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61486 61469 fi
61487 61470 fi
61488 61471 fi
61489 61472
61490 61473
61491 61474 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61492 61475 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
61493 61476 $as_echo_n "checking for freetype includes... " >&6; }
61494 61477 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
61495 61478 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
61496 61479 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
61497 61480 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
61498 61481 $as_echo_n "checking for freetype libraries... " >&6; }
61499 61482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
61500 61483 $as_echo "$FREETYPE_LIB_PATH" >&6; }
61501 61484 fi
61502 61485
61503 61486 fi
61504 61487
61505 61488 if test "x$FOUND_FREETYPE" != xyes; then
61506 61489 FREETYPE_BASE_DIR="$SYSROOT/usr"
61507 61490 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
61508 61491
61509 61492 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
61510 61493 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib/x86_64-linux-gnu"
61511 61494 METHOD="well-known location"
61512 61495
61513 61496 # Let's start with an optimistic view of the world :-)
61514 61497 FOUND_FREETYPE=yes
61515 61498
61516 61499 # First look for the canonical freetype main include file ft2build.h.
61517 61500 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61518 61501 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
61519 61502 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
61520 61503 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61521 61504 # Fail.
61522 61505 FOUND_FREETYPE=no
61523 61506 fi
61524 61507 fi
61525 61508
61526 61509 if test "x$FOUND_FREETYPE" = xyes; then
61527 61510 # Include file found, let's continue the sanity check.
61528 61511 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
61529 61512 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
61530 61513
61531 61514 # Reset to default value
61532 61515 FREETYPE_BASE_NAME=freetype
61533 61516 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61534 61517 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
61535 61518 if test "x$OPENJDK_TARGET_OS" = xmacosx \
61536 61519 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
61537 61520 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
61538 61521 # for the .6 version explicitly.
61539 61522 FREETYPE_BASE_NAME=freetype.6
61540 61523 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61541 61524 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
61542 61525 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
61543 61526 else
61544 61527 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
61545 61528 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
61546 61529 FOUND_FREETYPE=no
61547 61530 fi
61548 61531 else
61549 61532 if test "x$OPENJDK_TARGET_OS" = xwindows; then
61550 61533 # On Windows, we will need both .lib and .dll file.
61551 61534 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
61552 61535 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
61553 61536 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
61554 61537 FOUND_FREETYPE=no
61555 61538 fi
61556 61539 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
61557 61540 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
61558 61541 # Found lib in isa dir, use that instead.
61559 61542 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
61560 61543 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
61561 61544 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
61562 61545 fi
61563 61546 fi
61564 61547 fi
61565 61548
61566 61549 if test "x$FOUND_FREETYPE" = xyes; then
61567 61550
61568 61551 # Only process if variable expands to non-empty
61569 61552
61570 61553 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
61571 61554 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61572 61555
61573 61556 # Input might be given as Windows format, start by converting to
61574 61557 # unix format.
61575 61558 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61576 61559 new_path=`$CYGPATH -u "$path"`
61577 61560
61578 61561 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61579 61562 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61580 61563 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61581 61564 # "foo.exe" is OK but "foo" is an error.
61582 61565 #
61583 61566 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61584 61567 # It is also a way to make sure we got the proper file name for the real test later on.
61585 61568 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61586 61569 if test "x$test_shortpath" = x; then
61587 61570 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
61588 61571 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
61589 61572 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
61590 61573 fi
61591 61574
61592 61575 # Call helper function which possibly converts this using DOS-style short mode.
61593 61576 # If so, the updated path is stored in $new_path.
61594 61577
61595 61578 input_path="$new_path"
61596 61579 # Check if we need to convert this using DOS-style short mode. If the path
61597 61580 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61598 61581 # take no chances and rewrite it.
61599 61582 # Note: m4 eats our [], so we need to use [ and ] instead.
61600 61583 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61601 61584 if test "x$has_forbidden_chars" != x; then
61602 61585 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61603 61586 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61604 61587 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61605 61588 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61606 61589 # Going to short mode and back again did indeed matter. Since short mode is
61607 61590 # case insensitive, let's make it lowercase to improve readability.
61608 61591 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61609 61592 # Now convert it back to Unix-style (cygpath)
61610 61593 input_path=`$CYGPATH -u "$shortmode_path"`
61611 61594 new_path="$input_path"
61612 61595 fi
61613 61596 fi
61614 61597
61615 61598 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61616 61599 if test "x$test_cygdrive_prefix" = x; then
61617 61600 # As a simple fix, exclude /usr/bin since it's not a real path.
61618 61601 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61619 61602 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61620 61603 # a path prefixed by /cygdrive for fixpath to work.
61621 61604 new_path="$CYGWIN_ROOT_PATH$input_path"
61622 61605 fi
61623 61606 fi
61624 61607
61625 61608
61626 61609 if test "x$path" != "x$new_path"; then
61627 61610 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
61628 61611 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
61629 61612 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
61630 61613 fi
61631 61614
61632 61615 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61633 61616
61634 61617 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61635 61618 has_colon=`$ECHO $path | $GREP ^.:`
61636 61619 new_path="$path"
61637 61620 if test "x$has_colon" = x; then
61638 61621 # Not in mixed or Windows style, start by that.
61639 61622 new_path=`cmd //c echo $path`
61640 61623 fi
61641 61624
61642 61625
61643 61626 input_path="$new_path"
61644 61627 # Check if we need to convert this using DOS-style short mode. If the path
61645 61628 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61646 61629 # take no chances and rewrite it.
61647 61630 # Note: m4 eats our [], so we need to use [ and ] instead.
61648 61631 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61649 61632 if test "x$has_forbidden_chars" != x; then
61650 61633 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61651 61634 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61652 61635 fi
61653 61636
61654 61637
61655 61638 windows_path="$new_path"
61656 61639 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61657 61640 unix_path=`$CYGPATH -u "$windows_path"`
61658 61641 new_path="$unix_path"
61659 61642 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61660 61643 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61661 61644 new_path="$unix_path"
61662 61645 fi
61663 61646
61664 61647 if test "x$path" != "x$new_path"; then
61665 61648 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
61666 61649 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
61667 61650 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
61668 61651 fi
61669 61652
61670 61653 # Save the first 10 bytes of this path to the storage, so fixpath can work.
61671 61654 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
61672 61655
61673 61656 else
61674 61657 # We're on a unix platform. Hooray! :)
61675 61658 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61676 61659 has_space=`$ECHO "$path" | $GREP " "`
61677 61660 if test "x$has_space" != x; then
61678 61661 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
61679 61662 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
61680 61663 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
61681 61664 fi
61682 61665
61683 61666 # Use eval to expand a potential ~
61684 61667 eval path="$path"
61685 61668 if test ! -f "$path" && test ! -d "$path"; then
61686 61669 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61687 61670 fi
61688 61671
61689 61672 if test -d "$path"; then
61690 61673 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
61691 61674 else
61692 61675 dir="`$DIRNAME "$path"`"
61693 61676 base="`$BASENAME "$path"`"
61694 61677 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61695 61678 fi
61696 61679 fi
61697 61680 fi
61698 61681
61699 61682
61700 61683 # Only process if variable expands to non-empty
61701 61684
61702 61685 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
61703 61686 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61704 61687
61705 61688 # Input might be given as Windows format, start by converting to
61706 61689 # unix format.
61707 61690 path="$POTENTIAL_FREETYPE_LIB_PATH"
61708 61691 new_path=`$CYGPATH -u "$path"`
61709 61692
61710 61693 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61711 61694 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61712 61695 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61713 61696 # "foo.exe" is OK but "foo" is an error.
61714 61697 #
61715 61698 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61716 61699 # It is also a way to make sure we got the proper file name for the real test later on.
61717 61700 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61718 61701 if test "x$test_shortpath" = x; then
61719 61702 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61720 61703 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61721 61704 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
61722 61705 fi
61723 61706
61724 61707 # Call helper function which possibly converts this using DOS-style short mode.
61725 61708 # If so, the updated path is stored in $new_path.
61726 61709
61727 61710 input_path="$new_path"
61728 61711 # Check if we need to convert this using DOS-style short mode. If the path
61729 61712 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61730 61713 # take no chances and rewrite it.
61731 61714 # Note: m4 eats our [], so we need to use [ and ] instead.
61732 61715 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61733 61716 if test "x$has_forbidden_chars" != x; then
61734 61717 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61735 61718 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61736 61719 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61737 61720 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61738 61721 # Going to short mode and back again did indeed matter. Since short mode is
61739 61722 # case insensitive, let's make it lowercase to improve readability.
61740 61723 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61741 61724 # Now convert it back to Unix-style (cygpath)
61742 61725 input_path=`$CYGPATH -u "$shortmode_path"`
61743 61726 new_path="$input_path"
61744 61727 fi
61745 61728 fi
61746 61729
61747 61730 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61748 61731 if test "x$test_cygdrive_prefix" = x; then
61749 61732 # As a simple fix, exclude /usr/bin since it's not a real path.
61750 61733 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61751 61734 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61752 61735 # a path prefixed by /cygdrive for fixpath to work.
61753 61736 new_path="$CYGWIN_ROOT_PATH$input_path"
61754 61737 fi
61755 61738 fi
61756 61739
61757 61740
61758 61741 if test "x$path" != "x$new_path"; then
61759 61742 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61760 61743 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61761 61744 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61762 61745 fi
61763 61746
61764 61747 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61765 61748
61766 61749 path="$POTENTIAL_FREETYPE_LIB_PATH"
61767 61750 has_colon=`$ECHO $path | $GREP ^.:`
61768 61751 new_path="$path"
61769 61752 if test "x$has_colon" = x; then
61770 61753 # Not in mixed or Windows style, start by that.
61771 61754 new_path=`cmd //c echo $path`
61772 61755 fi
61773 61756
61774 61757
61775 61758 input_path="$new_path"
61776 61759 # Check if we need to convert this using DOS-style short mode. If the path
61777 61760 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61778 61761 # take no chances and rewrite it.
61779 61762 # Note: m4 eats our [], so we need to use [ and ] instead.
61780 61763 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61781 61764 if test "x$has_forbidden_chars" != x; then
61782 61765 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61783 61766 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61784 61767 fi
61785 61768
61786 61769
61787 61770 windows_path="$new_path"
61788 61771 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61789 61772 unix_path=`$CYGPATH -u "$windows_path"`
61790 61773 new_path="$unix_path"
61791 61774 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61792 61775 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61793 61776 new_path="$unix_path"
61794 61777 fi
61795 61778
61796 61779 if test "x$path" != "x$new_path"; then
61797 61780 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
61798 61781 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
61799 61782 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
61800 61783 fi
61801 61784
61802 61785 # Save the first 10 bytes of this path to the storage, so fixpath can work.
61803 61786 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
61804 61787
61805 61788 else
61806 61789 # We're on a unix platform. Hooray! :)
61807 61790 path="$POTENTIAL_FREETYPE_LIB_PATH"
61808 61791 has_space=`$ECHO "$path" | $GREP " "`
61809 61792 if test "x$has_space" != x; then
61810 61793 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
61811 61794 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
61812 61795 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
61813 61796 fi
61814 61797
61815 61798 # Use eval to expand a potential ~
61816 61799 eval path="$path"
61817 61800 if test ! -f "$path" && test ! -d "$path"; then
61818 61801 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
61819 61802 fi
61820 61803
61821 61804 if test -d "$path"; then
61822 61805 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
61823 61806 else
61824 61807 dir="`$DIRNAME "$path"`"
61825 61808 base="`$BASENAME "$path"`"
61826 61809 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
61827 61810 fi
61828 61811 fi
61829 61812 fi
61830 61813
61831 61814
61832 61815 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61833 61816 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
61834 61817 $as_echo_n "checking for freetype includes... " >&6; }
61835 61818 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
61836 61819 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
61837 61820 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
61838 61821 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
61839 61822 $as_echo_n "checking for freetype libraries... " >&6; }
61840 61823 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
61841 61824 $as_echo "$FREETYPE_LIB_PATH" >&6; }
61842 61825 fi
61843 61826
61844 61827 else
61845 61828
61846 61829 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
61847 61830 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib/i386-linux-gnu"
61848 61831 METHOD="well-known location"
61849 61832
61850 61833 # Let's start with an optimistic view of the world :-)
61851 61834 FOUND_FREETYPE=yes
61852 61835
61853 61836 # First look for the canonical freetype main include file ft2build.h.
61854 61837 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61855 61838 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
61856 61839 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
61857 61840 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
61858 61841 # Fail.
61859 61842 FOUND_FREETYPE=no
61860 61843 fi
61861 61844 fi
61862 61845
61863 61846 if test "x$FOUND_FREETYPE" = xyes; then
61864 61847 # Include file found, let's continue the sanity check.
61865 61848 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
61866 61849 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
61867 61850
61868 61851 # Reset to default value
61869 61852 FREETYPE_BASE_NAME=freetype
61870 61853 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61871 61854 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
61872 61855 if test "x$OPENJDK_TARGET_OS" = xmacosx \
61873 61856 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
61874 61857 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
61875 61858 # for the .6 version explicitly.
61876 61859 FREETYPE_BASE_NAME=freetype.6
61877 61860 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
61878 61861 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
61879 61862 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
61880 61863 else
61881 61864 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
61882 61865 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
61883 61866 FOUND_FREETYPE=no
61884 61867 fi
61885 61868 else
61886 61869 if test "x$OPENJDK_TARGET_OS" = xwindows; then
61887 61870 # On Windows, we will need both .lib and .dll file.
61888 61871 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
61889 61872 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
61890 61873 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
61891 61874 FOUND_FREETYPE=no
61892 61875 fi
61893 61876 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
61894 61877 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
61895 61878 # Found lib in isa dir, use that instead.
61896 61879 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
61897 61880 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
61898 61881 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
61899 61882 fi
61900 61883 fi
61901 61884 fi
61902 61885
61903 61886 if test "x$FOUND_FREETYPE" = xyes; then
61904 61887
61905 61888 # Only process if variable expands to non-empty
61906 61889
61907 61890 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
61908 61891 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61909 61892
61910 61893 # Input might be given as Windows format, start by converting to
61911 61894 # unix format.
61912 61895 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61913 61896 new_path=`$CYGPATH -u "$path"`
61914 61897
61915 61898 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
61916 61899 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
61917 61900 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
61918 61901 # "foo.exe" is OK but "foo" is an error.
61919 61902 #
61920 61903 # This test is therefore slightly more accurate than "test -f" to check for file precense.
61921 61904 # It is also a way to make sure we got the proper file name for the real test later on.
61922 61905 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
61923 61906 if test "x$test_shortpath" = x; then
61924 61907 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
61925 61908 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
61926 61909 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
61927 61910 fi
61928 61911
61929 61912 # Call helper function which possibly converts this using DOS-style short mode.
61930 61913 # If so, the updated path is stored in $new_path.
61931 61914
61932 61915 input_path="$new_path"
61933 61916 # Check if we need to convert this using DOS-style short mode. If the path
61934 61917 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61935 61918 # take no chances and rewrite it.
61936 61919 # Note: m4 eats our [], so we need to use [ and ] instead.
61937 61920 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
61938 61921 if test "x$has_forbidden_chars" != x; then
61939 61922 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61940 61923 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
61941 61924 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
61942 61925 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
61943 61926 # Going to short mode and back again did indeed matter. Since short mode is
61944 61927 # case insensitive, let's make it lowercase to improve readability.
61945 61928 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61946 61929 # Now convert it back to Unix-style (cygpath)
61947 61930 input_path=`$CYGPATH -u "$shortmode_path"`
61948 61931 new_path="$input_path"
61949 61932 fi
61950 61933 fi
61951 61934
61952 61935 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
61953 61936 if test "x$test_cygdrive_prefix" = x; then
61954 61937 # As a simple fix, exclude /usr/bin since it's not a real path.
61955 61938 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
61956 61939 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
61957 61940 # a path prefixed by /cygdrive for fixpath to work.
61958 61941 new_path="$CYGWIN_ROOT_PATH$input_path"
61959 61942 fi
61960 61943 fi
61961 61944
61962 61945
61963 61946 if test "x$path" != "x$new_path"; then
61964 61947 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
61965 61948 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
61966 61949 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
61967 61950 fi
61968 61951
61969 61952 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61970 61953
61971 61954 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
61972 61955 has_colon=`$ECHO $path | $GREP ^.:`
61973 61956 new_path="$path"
61974 61957 if test "x$has_colon" = x; then
61975 61958 # Not in mixed or Windows style, start by that.
61976 61959 new_path=`cmd //c echo $path`
61977 61960 fi
61978 61961
61979 61962
61980 61963 input_path="$new_path"
61981 61964 # Check if we need to convert this using DOS-style short mode. If the path
61982 61965 # contains just simple characters, use it. Otherwise (spaces, weird characters),
61983 61966 # take no chances and rewrite it.
61984 61967 # Note: m4 eats our [], so we need to use [ and ] instead.
61985 61968 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
61986 61969 if test "x$has_forbidden_chars" != x; then
61987 61970 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
61988 61971 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
61989 61972 fi
61990 61973
61991 61974
61992 61975 windows_path="$new_path"
61993 61976 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
61994 61977 unix_path=`$CYGPATH -u "$windows_path"`
61995 61978 new_path="$unix_path"
61996 61979 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
61997 61980 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
61998 61981 new_path="$unix_path"
61999 61982 fi
62000 61983
62001 61984 if test "x$path" != "x$new_path"; then
62002 61985 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
62003 61986 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
62004 61987 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
62005 61988 fi
62006 61989
62007 61990 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62008 61991 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62009 61992
62010 61993 else
62011 61994 # We're on a unix platform. Hooray! :)
62012 61995 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62013 61996 has_space=`$ECHO "$path" | $GREP " "`
62014 61997 if test "x$has_space" != x; then
62015 61998 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
62016 61999 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
62017 62000 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62018 62001 fi
62019 62002
62020 62003 # Use eval to expand a potential ~
62021 62004 eval path="$path"
62022 62005 if test ! -f "$path" && test ! -d "$path"; then
62023 62006 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62024 62007 fi
62025 62008
62026 62009 if test -d "$path"; then
62027 62010 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
62028 62011 else
62029 62012 dir="`$DIRNAME "$path"`"
62030 62013 base="`$BASENAME "$path"`"
62031 62014 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62032 62015 fi
62033 62016 fi
62034 62017 fi
62035 62018
62036 62019
62037 62020 # Only process if variable expands to non-empty
62038 62021
62039 62022 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
62040 62023 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62041 62024
62042 62025 # Input might be given as Windows format, start by converting to
62043 62026 # unix format.
62044 62027 path="$POTENTIAL_FREETYPE_LIB_PATH"
62045 62028 new_path=`$CYGPATH -u "$path"`
62046 62029
62047 62030 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
62048 62031 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
62049 62032 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
62050 62033 # "foo.exe" is OK but "foo" is an error.
62051 62034 #
62052 62035 # This test is therefore slightly more accurate than "test -f" to check for file precense.
62053 62036 # It is also a way to make sure we got the proper file name for the real test later on.
62054 62037 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
62055 62038 if test "x$test_shortpath" = x; then
62056 62039 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62057 62040 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62058 62041 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
62059 62042 fi
62060 62043
62061 62044 # Call helper function which possibly converts this using DOS-style short mode.
62062 62045 # If so, the updated path is stored in $new_path.
62063 62046
62064 62047 input_path="$new_path"
62065 62048 # Check if we need to convert this using DOS-style short mode. If the path
62066 62049 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62067 62050 # take no chances and rewrite it.
62068 62051 # Note: m4 eats our [], so we need to use [ and ] instead.
62069 62052 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
62070 62053 if test "x$has_forbidden_chars" != x; then
62071 62054 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62072 62055 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
62073 62056 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
62074 62057 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
62075 62058 # Going to short mode and back again did indeed matter. Since short mode is
62076 62059 # case insensitive, let's make it lowercase to improve readability.
62077 62060 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62078 62061 # Now convert it back to Unix-style (cygpath)
62079 62062 input_path=`$CYGPATH -u "$shortmode_path"`
62080 62063 new_path="$input_path"
62081 62064 fi
62082 62065 fi
62083 62066
62084 62067 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
62085 62068 if test "x$test_cygdrive_prefix" = x; then
62086 62069 # As a simple fix, exclude /usr/bin since it's not a real path.
62087 62070 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
62088 62071 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
62089 62072 # a path prefixed by /cygdrive for fixpath to work.
62090 62073 new_path="$CYGWIN_ROOT_PATH$input_path"
62091 62074 fi
62092 62075 fi
62093 62076
62094 62077
62095 62078 if test "x$path" != "x$new_path"; then
62096 62079 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
62097 62080 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
62098 62081 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62099 62082 fi
62100 62083
62101 62084 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62102 62085
62103 62086 path="$POTENTIAL_FREETYPE_LIB_PATH"
62104 62087 has_colon=`$ECHO $path | $GREP ^.:`
62105 62088 new_path="$path"
62106 62089 if test "x$has_colon" = x; then
62107 62090 # Not in mixed or Windows style, start by that.
62108 62091 new_path=`cmd //c echo $path`
62109 62092 fi
62110 62093
62111 62094
62112 62095 input_path="$new_path"
62113 62096 # Check if we need to convert this using DOS-style short mode. If the path
62114 62097 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62115 62098 # take no chances and rewrite it.
62116 62099 # Note: m4 eats our [], so we need to use [ and ] instead.
62117 62100 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
62118 62101 if test "x$has_forbidden_chars" != x; then
62119 62102 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62120 62103 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62121 62104 fi
62122 62105
62123 62106
62124 62107 windows_path="$new_path"
62125 62108 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62126 62109 unix_path=`$CYGPATH -u "$windows_path"`
62127 62110 new_path="$unix_path"
62128 62111 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62129 62112 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
62130 62113 new_path="$unix_path"
62131 62114 fi
62132 62115
62133 62116 if test "x$path" != "x$new_path"; then
62134 62117 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
62135 62118 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
62136 62119 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62137 62120 fi
62138 62121
62139 62122 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62140 62123 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62141 62124
62142 62125 else
62143 62126 # We're on a unix platform. Hooray! :)
62144 62127 path="$POTENTIAL_FREETYPE_LIB_PATH"
62145 62128 has_space=`$ECHO "$path" | $GREP " "`
62146 62129 if test "x$has_space" != x; then
62147 62130 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62148 62131 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62149 62132 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62150 62133 fi
62151 62134
62152 62135 # Use eval to expand a potential ~
62153 62136 eval path="$path"
62154 62137 if test ! -f "$path" && test ! -d "$path"; then
62155 62138 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62156 62139 fi
62157 62140
62158 62141 if test -d "$path"; then
62159 62142 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
62160 62143 else
62161 62144 dir="`$DIRNAME "$path"`"
62162 62145 base="`$BASENAME "$path"`"
62163 62146 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62164 62147 fi
62165 62148 fi
62166 62149 fi
62167 62150
62168 62151
62169 62152 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62170 62153 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
62171 62154 $as_echo_n "checking for freetype includes... " >&6; }
62172 62155 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
62173 62156 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
62174 62157 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
62175 62158 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
62176 62159 $as_echo_n "checking for freetype libraries... " >&6; }
62177 62160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
62178 62161 $as_echo "$FREETYPE_LIB_PATH" >&6; }
62179 62162 fi
62180 62163
62181 62164 if test "x$FOUND_FREETYPE" != xyes; then
62182 62165
62183 62166 POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
62184 62167 POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
62185 62168 METHOD="well-known location"
62186 62169
62187 62170 # Let's start with an optimistic view of the world :-)
62188 62171 FOUND_FREETYPE=yes
62189 62172
62190 62173 # First look for the canonical freetype main include file ft2build.h.
62191 62174 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
62192 62175 # Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
62193 62176 POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
62194 62177 if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
62195 62178 # Fail.
62196 62179 FOUND_FREETYPE=no
62197 62180 fi
62198 62181 fi
62199 62182
62200 62183 if test "x$FOUND_FREETYPE" = xyes; then
62201 62184 # Include file found, let's continue the sanity check.
62202 62185 { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
62203 62186 $as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
62204 62187
62205 62188 # Reset to default value
62206 62189 FREETYPE_BASE_NAME=freetype
62207 62190 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
62208 62191 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
62209 62192 if test "x$OPENJDK_TARGET_OS" = xmacosx \
62210 62193 && test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
62211 62194 # On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
62212 62195 # for the .6 version explicitly.
62213 62196 FREETYPE_BASE_NAME=freetype.6
62214 62197 FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
62215 62198 { $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
62216 62199 $as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
62217 62200 else
62218 62201 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
62219 62202 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
62220 62203 FOUND_FREETYPE=no
62221 62204 fi
62222 62205 else
62223 62206 if test "x$OPENJDK_TARGET_OS" = xwindows; then
62224 62207 # On Windows, we will need both .lib and .dll file.
62225 62208 if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
62226 62209 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
62227 62210 $as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
62228 62211 FOUND_FREETYPE=no
62229 62212 fi
62230 62213 elif test "x$OPENJDK_TARGET_OS" = xsolaris \
62231 62214 && test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
62232 62215 # Found lib in isa dir, use that instead.
62233 62216 POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
62234 62217 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
62235 62218 $as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
62236 62219 fi
62237 62220 fi
62238 62221 fi
62239 62222
62240 62223 if test "x$FOUND_FREETYPE" = xyes; then
62241 62224
62242 62225 # Only process if variable expands to non-empty
62243 62226
62244 62227 if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
62245 62228 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62246 62229
62247 62230 # Input might be given as Windows format, start by converting to
62248 62231 # unix format.
62249 62232 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62250 62233 new_path=`$CYGPATH -u "$path"`
62251 62234
62252 62235 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
62253 62236 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
62254 62237 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
62255 62238 # "foo.exe" is OK but "foo" is an error.
62256 62239 #
62257 62240 # This test is therefore slightly more accurate than "test -f" to check for file precense.
62258 62241 # It is also a way to make sure we got the proper file name for the real test later on.
62259 62242 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
62260 62243 if test "x$test_shortpath" = x; then
62261 62244 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
62262 62245 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
62263 62246 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
62264 62247 fi
62265 62248
62266 62249 # Call helper function which possibly converts this using DOS-style short mode.
62267 62250 # If so, the updated path is stored in $new_path.
62268 62251
62269 62252 input_path="$new_path"
62270 62253 # Check if we need to convert this using DOS-style short mode. If the path
62271 62254 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62272 62255 # take no chances and rewrite it.
62273 62256 # Note: m4 eats our [], so we need to use [ and ] instead.
62274 62257 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
62275 62258 if test "x$has_forbidden_chars" != x; then
62276 62259 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62277 62260 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
62278 62261 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
62279 62262 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
62280 62263 # Going to short mode and back again did indeed matter. Since short mode is
62281 62264 # case insensitive, let's make it lowercase to improve readability.
62282 62265 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62283 62266 # Now convert it back to Unix-style (cygpath)
62284 62267 input_path=`$CYGPATH -u "$shortmode_path"`
62285 62268 new_path="$input_path"
62286 62269 fi
62287 62270 fi
62288 62271
62289 62272 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
62290 62273 if test "x$test_cygdrive_prefix" = x; then
62291 62274 # As a simple fix, exclude /usr/bin since it's not a real path.
62292 62275 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
62293 62276 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
62294 62277 # a path prefixed by /cygdrive for fixpath to work.
62295 62278 new_path="$CYGWIN_ROOT_PATH$input_path"
62296 62279 fi
62297 62280 fi
62298 62281
62299 62282
62300 62283 if test "x$path" != "x$new_path"; then
62301 62284 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
62302 62285 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
62303 62286 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
62304 62287 fi
62305 62288
62306 62289 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62307 62290
62308 62291 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62309 62292 has_colon=`$ECHO $path | $GREP ^.:`
62310 62293 new_path="$path"
62311 62294 if test "x$has_colon" = x; then
62312 62295 # Not in mixed or Windows style, start by that.
62313 62296 new_path=`cmd //c echo $path`
62314 62297 fi
62315 62298
62316 62299
62317 62300 input_path="$new_path"
62318 62301 # Check if we need to convert this using DOS-style short mode. If the path
62319 62302 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62320 62303 # take no chances and rewrite it.
62321 62304 # Note: m4 eats our [], so we need to use [ and ] instead.
62322 62305 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
62323 62306 if test "x$has_forbidden_chars" != x; then
62324 62307 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62325 62308 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62326 62309 fi
62327 62310
62328 62311
62329 62312 windows_path="$new_path"
62330 62313 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62331 62314 unix_path=`$CYGPATH -u "$windows_path"`
62332 62315 new_path="$unix_path"
62333 62316 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62334 62317 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
62335 62318 new_path="$unix_path"
62336 62319 fi
62337 62320
62338 62321 if test "x$path" != "x$new_path"; then
62339 62322 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
62340 62323 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
62341 62324 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
62342 62325 fi
62343 62326
62344 62327 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62345 62328 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62346 62329
62347 62330 else
62348 62331 # We're on a unix platform. Hooray! :)
62349 62332 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62350 62333 has_space=`$ECHO "$path" | $GREP " "`
62351 62334 if test "x$has_space" != x; then
62352 62335 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
62353 62336 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
62354 62337 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62355 62338 fi
62356 62339
62357 62340 # Use eval to expand a potential ~
62358 62341 eval path="$path"
62359 62342 if test ! -f "$path" && test ! -d "$path"; then
62360 62343 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62361 62344 fi
62362 62345
62363 62346 if test -d "$path"; then
62364 62347 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
62365 62348 else
62366 62349 dir="`$DIRNAME "$path"`"
62367 62350 base="`$BASENAME "$path"`"
62368 62351 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62369 62352 fi
62370 62353 fi
62371 62354 fi
62372 62355
62373 62356
62374 62357 # Only process if variable expands to non-empty
62375 62358
62376 62359 if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
62377 62360 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62378 62361
62379 62362 # Input might be given as Windows format, start by converting to
62380 62363 # unix format.
62381 62364 path="$POTENTIAL_FREETYPE_LIB_PATH"
62382 62365 new_path=`$CYGPATH -u "$path"`
62383 62366
62384 62367 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
62385 62368 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
62386 62369 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
62387 62370 # "foo.exe" is OK but "foo" is an error.
62388 62371 #
62389 62372 # This test is therefore slightly more accurate than "test -f" to check for file precense.
62390 62373 # It is also a way to make sure we got the proper file name for the real test later on.
62391 62374 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
62392 62375 if test "x$test_shortpath" = x; then
62393 62376 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62394 62377 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62395 62378 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
62396 62379 fi
62397 62380
62398 62381 # Call helper function which possibly converts this using DOS-style short mode.
62399 62382 # If so, the updated path is stored in $new_path.
62400 62383
62401 62384 input_path="$new_path"
62402 62385 # Check if we need to convert this using DOS-style short mode. If the path
62403 62386 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62404 62387 # take no chances and rewrite it.
62405 62388 # Note: m4 eats our [], so we need to use [ and ] instead.
62406 62389 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
62407 62390 if test "x$has_forbidden_chars" != x; then
62408 62391 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62409 62392 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
62410 62393 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
62411 62394 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
62412 62395 # Going to short mode and back again did indeed matter. Since short mode is
62413 62396 # case insensitive, let's make it lowercase to improve readability.
62414 62397 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62415 62398 # Now convert it back to Unix-style (cygpath)
62416 62399 input_path=`$CYGPATH -u "$shortmode_path"`
62417 62400 new_path="$input_path"
62418 62401 fi
62419 62402 fi
62420 62403
62421 62404 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
62422 62405 if test "x$test_cygdrive_prefix" = x; then
62423 62406 # As a simple fix, exclude /usr/bin since it's not a real path.
62424 62407 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
62425 62408 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
62426 62409 # a path prefixed by /cygdrive for fixpath to work.
62427 62410 new_path="$CYGWIN_ROOT_PATH$input_path"
62428 62411 fi
62429 62412 fi
62430 62413
62431 62414
62432 62415 if test "x$path" != "x$new_path"; then
62433 62416 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
62434 62417 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
62435 62418 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62436 62419 fi
62437 62420
62438 62421 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62439 62422
62440 62423 path="$POTENTIAL_FREETYPE_LIB_PATH"
62441 62424 has_colon=`$ECHO $path | $GREP ^.:`
62442 62425 new_path="$path"
62443 62426 if test "x$has_colon" = x; then
62444 62427 # Not in mixed or Windows style, start by that.
62445 62428 new_path=`cmd //c echo $path`
62446 62429 fi
62447 62430
62448 62431
62449 62432 input_path="$new_path"
62450 62433 # Check if we need to convert this using DOS-style short mode. If the path
62451 62434 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62452 62435 # take no chances and rewrite it.
62453 62436 # Note: m4 eats our [], so we need to use [ and ] instead.
62454 62437 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
62455 62438 if test "x$has_forbidden_chars" != x; then
62456 62439 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62457 62440 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62458 62441 fi
62459 62442
62460 62443
62461 62444 windows_path="$new_path"
62462 62445 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62463 62446 unix_path=`$CYGPATH -u "$windows_path"`
62464 62447 new_path="$unix_path"
62465 62448 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62466 62449 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
62467 62450 new_path="$unix_path"
62468 62451 fi
62469 62452
62470 62453 if test "x$path" != "x$new_path"; then
62471 62454 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
62472 62455 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
62473 62456 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62474 62457 fi
62475 62458
62476 62459 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62477 62460 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62478 62461
62479 62462 else
62480 62463 # We're on a unix platform. Hooray! :)
62481 62464 path="$POTENTIAL_FREETYPE_LIB_PATH"
62482 62465 has_space=`$ECHO "$path" | $GREP " "`
62483 62466 if test "x$has_space" != x; then
62484 62467 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62485 62468 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62486 62469 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62487 62470 fi
62488 62471
62489 62472 # Use eval to expand a potential ~
62490 62473 eval path="$path"
62491 62474 if test ! -f "$path" && test ! -d "$path"; then
62492 62475 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62493 62476 fi
62494 62477
62495 62478 if test -d "$path"; then
62496 62479 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
62497 62480 else
62498 62481 dir="`$DIRNAME "$path"`"
62499 62482 base="`$BASENAME "$path"`"
62500 62483 POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62501 62484 fi
62502 62485 fi
62503 62486 fi
62504 62487
62505 62488
62506 62489 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
62507 62490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
62508 62491 $as_echo_n "checking for freetype includes... " >&6; }
62509 62492 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
62510 62493 $as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
62511 62494 FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
62512 62495 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
62513 62496 $as_echo_n "checking for freetype libraries... " >&6; }
62514 62497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
62515 62498 $as_echo "$FREETYPE_LIB_PATH" >&6; }
62516 62499 fi
62517 62500
62518 62501 fi
62519 62502 fi
62520 62503 fi
62521 62504 fi
62522 62505 fi # end check in well-known locations
62523 62506
62524 62507 if test "x$FOUND_FREETYPE" != xyes; then
62525 62508
62526 62509 # Print a helpful message on how to acquire the necessary build dependency.
62527 62510 # freetype is the help tag: freetype, cups, alsa etc
62528 62511 MISSING_DEPENDENCY=freetype
62529 62512
62530 62513 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62531 62514 cygwin_help $MISSING_DEPENDENCY
62532 62515 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62533 62516 msys_help $MISSING_DEPENDENCY
62534 62517 else
62535 62518 PKGHANDLER_COMMAND=
62536 62519
62537 62520 case $PKGHANDLER in
62538 62521 apt-get)
62539 62522 apt_help $MISSING_DEPENDENCY ;;
62540 62523 yum)
62541 62524 yum_help $MISSING_DEPENDENCY ;;
62542 62525 port)
62543 62526 port_help $MISSING_DEPENDENCY ;;
62544 62527 pkgutil)
62545 62528 pkgutil_help $MISSING_DEPENDENCY ;;
62546 62529 pkgadd)
62547 62530 pkgadd_help $MISSING_DEPENDENCY ;;
62548 62531 esac
62549 62532
62550 62533 if test "x$PKGHANDLER_COMMAND" != x; then
62551 62534 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
62552 62535 fi
62553 62536 fi
62554 62537
62555 62538 as_fn_error $? "Could not find freetype! $HELP_MSG " "$LINENO" 5
62556 62539 fi
62557 62540 fi # end user specified settings
62558 62541
62559 62542 # Set FREETYPE_CFLAGS, _LIBS and _LIB_PATH from include and lib dir.
62560 62543 if test "x$FREETYPE_CFLAGS" = x; then
62561 62544
62562 62545 # Only process if variable expands to non-empty
62563 62546
62564 62547 if test "x$FREETYPE_INCLUDE_PATH" != x; then
62565 62548 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62566 62549
62567 62550 # Input might be given as Windows format, start by converting to
62568 62551 # unix format.
62569 62552 path="$FREETYPE_INCLUDE_PATH"
62570 62553 new_path=`$CYGPATH -u "$path"`
62571 62554
62572 62555 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
62573 62556 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
62574 62557 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
62575 62558 # "foo.exe" is OK but "foo" is an error.
62576 62559 #
62577 62560 # This test is therefore slightly more accurate than "test -f" to check for file precense.
62578 62561 # It is also a way to make sure we got the proper file name for the real test later on.
62579 62562 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
62580 62563 if test "x$test_shortpath" = x; then
62581 62564 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
62582 62565 $as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
62583 62566 as_fn_error $? "Cannot locate the the path of FREETYPE_INCLUDE_PATH" "$LINENO" 5
62584 62567 fi
62585 62568
62586 62569 # Call helper function which possibly converts this using DOS-style short mode.
62587 62570 # If so, the updated path is stored in $new_path.
62588 62571
62589 62572 input_path="$new_path"
62590 62573 # Check if we need to convert this using DOS-style short mode. If the path
62591 62574 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62592 62575 # take no chances and rewrite it.
62593 62576 # Note: m4 eats our [], so we need to use [ and ] instead.
62594 62577 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
62595 62578 if test "x$has_forbidden_chars" != x; then
62596 62579 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62597 62580 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
62598 62581 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
62599 62582 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
62600 62583 # Going to short mode and back again did indeed matter. Since short mode is
62601 62584 # case insensitive, let's make it lowercase to improve readability.
62602 62585 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62603 62586 # Now convert it back to Unix-style (cygpath)
62604 62587 input_path=`$CYGPATH -u "$shortmode_path"`
62605 62588 new_path="$input_path"
62606 62589 fi
62607 62590 fi
62608 62591
62609 62592 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
62610 62593 if test "x$test_cygdrive_prefix" = x; then
62611 62594 # As a simple fix, exclude /usr/bin since it's not a real path.
62612 62595 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
62613 62596 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
62614 62597 # a path prefixed by /cygdrive for fixpath to work.
62615 62598 new_path="$CYGWIN_ROOT_PATH$input_path"
62616 62599 fi
62617 62600 fi
62618 62601
62619 62602
62620 62603 if test "x$path" != "x$new_path"; then
62621 62604 FREETYPE_INCLUDE_PATH="$new_path"
62622 62605 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
62623 62606 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
62624 62607 fi
62625 62608
62626 62609 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62627 62610
62628 62611 path="$FREETYPE_INCLUDE_PATH"
62629 62612 has_colon=`$ECHO $path | $GREP ^.:`
62630 62613 new_path="$path"
62631 62614 if test "x$has_colon" = x; then
62632 62615 # Not in mixed or Windows style, start by that.
62633 62616 new_path=`cmd //c echo $path`
62634 62617 fi
62635 62618
62636 62619
62637 62620 input_path="$new_path"
62638 62621 # Check if we need to convert this using DOS-style short mode. If the path
62639 62622 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62640 62623 # take no chances and rewrite it.
62641 62624 # Note: m4 eats our [], so we need to use [ and ] instead.
62642 62625 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
62643 62626 if test "x$has_forbidden_chars" != x; then
62644 62627 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62645 62628 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62646 62629 fi
62647 62630
62648 62631
62649 62632 windows_path="$new_path"
62650 62633 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62651 62634 unix_path=`$CYGPATH -u "$windows_path"`
62652 62635 new_path="$unix_path"
62653 62636 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62654 62637 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
62655 62638 new_path="$unix_path"
62656 62639 fi
62657 62640
62658 62641 if test "x$path" != "x$new_path"; then
62659 62642 FREETYPE_INCLUDE_PATH="$new_path"
62660 62643 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
62661 62644 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
62662 62645 fi
62663 62646
62664 62647 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62665 62648 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62666 62649
62667 62650 else
62668 62651 # We're on a unix platform. Hooray! :)
62669 62652 path="$FREETYPE_INCLUDE_PATH"
62670 62653 has_space=`$ECHO "$path" | $GREP " "`
62671 62654 if test "x$has_space" != x; then
62672 62655 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
62673 62656 $as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
62674 62657 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62675 62658 fi
62676 62659
62677 62660 # Use eval to expand a potential ~
62678 62661 eval path="$path"
62679 62662 if test ! -f "$path" && test ! -d "$path"; then
62680 62663 as_fn_error $? "The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62681 62664 fi
62682 62665
62683 62666 if test -d "$path"; then
62684 62667 FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
62685 62668 else
62686 62669 dir="`$DIRNAME "$path"`"
62687 62670 base="`$BASENAME "$path"`"
62688 62671 FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62689 62672 fi
62690 62673 fi
62691 62674 fi
62692 62675
62693 62676 if test -d $FREETYPE_INCLUDE_PATH/freetype2/freetype; then
62694 62677 FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH/freetype2 -I$FREETYPE_INCLUDE_PATH"
62695 62678 else
62696 62679 FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH"
62697 62680 fi
62698 62681 fi
62699 62682
62700 62683 if test "x$FREETYPE_LIBS" = x; then
62701 62684
62702 62685 # Only process if variable expands to non-empty
62703 62686
62704 62687 if test "x$FREETYPE_LIB_PATH" != x; then
62705 62688 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62706 62689
62707 62690 # Input might be given as Windows format, start by converting to
62708 62691 # unix format.
62709 62692 path="$FREETYPE_LIB_PATH"
62710 62693 new_path=`$CYGPATH -u "$path"`
62711 62694
62712 62695 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
62713 62696 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
62714 62697 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
62715 62698 # "foo.exe" is OK but "foo" is an error.
62716 62699 #
62717 62700 # This test is therefore slightly more accurate than "test -f" to check for file precense.
62718 62701 # It is also a way to make sure we got the proper file name for the real test later on.
62719 62702 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
62720 62703 if test "x$test_shortpath" = x; then
62721 62704 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62722 62705 $as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62723 62706 as_fn_error $? "Cannot locate the the path of FREETYPE_LIB_PATH" "$LINENO" 5
62724 62707 fi
62725 62708
62726 62709 # Call helper function which possibly converts this using DOS-style short mode.
62727 62710 # If so, the updated path is stored in $new_path.
62728 62711
62729 62712 input_path="$new_path"
62730 62713 # Check if we need to convert this using DOS-style short mode. If the path
62731 62714 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62732 62715 # take no chances and rewrite it.
62733 62716 # Note: m4 eats our [], so we need to use [ and ] instead.
62734 62717 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
62735 62718 if test "x$has_forbidden_chars" != x; then
62736 62719 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62737 62720 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
62738 62721 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
62739 62722 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
62740 62723 # Going to short mode and back again did indeed matter. Since short mode is
62741 62724 # case insensitive, let's make it lowercase to improve readability.
62742 62725 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62743 62726 # Now convert it back to Unix-style (cygpath)
62744 62727 input_path=`$CYGPATH -u "$shortmode_path"`
62745 62728 new_path="$input_path"
62746 62729 fi
62747 62730 fi
62748 62731
62749 62732 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
62750 62733 if test "x$test_cygdrive_prefix" = x; then
62751 62734 # As a simple fix, exclude /usr/bin since it's not a real path.
62752 62735 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
62753 62736 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
62754 62737 # a path prefixed by /cygdrive for fixpath to work.
62755 62738 new_path="$CYGWIN_ROOT_PATH$input_path"
62756 62739 fi
62757 62740 fi
62758 62741
62759 62742
62760 62743 if test "x$path" != "x$new_path"; then
62761 62744 FREETYPE_LIB_PATH="$new_path"
62762 62745 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
62763 62746 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62764 62747 fi
62765 62748
62766 62749 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62767 62750
62768 62751 path="$FREETYPE_LIB_PATH"
62769 62752 has_colon=`$ECHO $path | $GREP ^.:`
62770 62753 new_path="$path"
62771 62754 if test "x$has_colon" = x; then
62772 62755 # Not in mixed or Windows style, start by that.
62773 62756 new_path=`cmd //c echo $path`
62774 62757 fi
62775 62758
62776 62759
62777 62760 input_path="$new_path"
62778 62761 # Check if we need to convert this using DOS-style short mode. If the path
62779 62762 # contains just simple characters, use it. Otherwise (spaces, weird characters),
62780 62763 # take no chances and rewrite it.
62781 62764 # Note: m4 eats our [], so we need to use [ and ] instead.
62782 62765 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
62783 62766 if test "x$has_forbidden_chars" != x; then
62784 62767 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
62785 62768 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
62786 62769 fi
62787 62770
62788 62771
62789 62772 windows_path="$new_path"
62790 62773 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62791 62774 unix_path=`$CYGPATH -u "$windows_path"`
62792 62775 new_path="$unix_path"
62793 62776 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62794 62777 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
62795 62778 new_path="$unix_path"
62796 62779 fi
62797 62780
62798 62781 if test "x$path" != "x$new_path"; then
62799 62782 FREETYPE_LIB_PATH="$new_path"
62800 62783 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
62801 62784 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
62802 62785 fi
62803 62786
62804 62787 # Save the first 10 bytes of this path to the storage, so fixpath can work.
62805 62788 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
62806 62789
62807 62790 else
62808 62791 # We're on a unix platform. Hooray! :)
62809 62792 path="$FREETYPE_LIB_PATH"
62810 62793 has_space=`$ECHO "$path" | $GREP " "`
62811 62794 if test "x$has_space" != x; then
62812 62795 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
62813 62796 $as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
62814 62797 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
62815 62798 fi
62816 62799
62817 62800 # Use eval to expand a potential ~
62818 62801 eval path="$path"
62819 62802 if test ! -f "$path" && test ! -d "$path"; then
62820 62803 as_fn_error $? "The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
62821 62804 fi
62822 62805
62823 62806 if test -d "$path"; then
62824 62807 FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
62825 62808 else
62826 62809 dir="`$DIRNAME "$path"`"
62827 62810 base="`$BASENAME "$path"`"
62828 62811 FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
62829 62812 fi
62830 62813 fi
62831 62814 fi
62832 62815
62833 62816 if test "x$OPENJDK_TARGET_OS" = xwindows; then
62834 62817 FREETYPE_LIBS="$FREETYPE_LIB_PATH/$FREETYPE_BASE_NAME.lib"
62835 62818 else
62836 62819 FREETYPE_LIBS="-L$FREETYPE_LIB_PATH -l$FREETYPE_BASE_NAME"
62837 62820 fi
62838 62821 fi
62839 62822
62840 62823 # Try to compile it
62841 62824 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can compile and link with freetype" >&5
62842 62825 $as_echo_n "checking if we can compile and link with freetype... " >&6; }
62843 62826 ac_ext=cpp
62844 62827 ac_cpp='$CXXCPP $CPPFLAGS'
62845 62828 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
62846 62829 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
62847 62830 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
62848 62831
62849 62832 PREV_CXXCFLAGS="$CXXFLAGS"
62850 62833 PREV_LIBS="$LIBS"
62851 62834 PREV_CXX="$CXX"
62852 62835 CXXFLAGS="$CXXFLAGS $FREETYPE_CFLAGS"
62853 62836 LIBS="$LIBS $FREETYPE_LIBS"
62854 62837 CXX="$FIXPATH $CXX"
62855 62838 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
62856 62839 /* end confdefs.h. */
62857 62840
62858 62841 #include<ft2build.h>
62859 62842 #include FT_FREETYPE_H
62860 62843 int main () {
62861 62844 FT_Init_FreeType(NULL);
62862 62845 return 0;
62863 62846 }
62864 62847
62865 62848 _ACEOF
62866 62849 if ac_fn_cxx_try_link "$LINENO"; then :
62867 62850
62868 62851 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
62869 62852 $as_echo "yes" >&6; }
62870 62853
62871 62854 else
62872 62855
62873 62856 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
62874 62857 $as_echo "no" >&6; }
62875 62858 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not compile and link with freetype. This might be a 32/64-bit mismatch." >&5
62876 62859 $as_echo "$as_me: Could not compile and link with freetype. This might be a 32/64-bit mismatch." >&6;}
62877 62860 { $as_echo "$as_me:${as_lineno-$LINENO}: Using FREETYPE_CFLAGS=$FREETYPE_CFLAGS and FREETYPE_LIBS=$FREETYPE_LIBS" >&5
62878 62861 $as_echo "$as_me: Using FREETYPE_CFLAGS=$FREETYPE_CFLAGS and FREETYPE_LIBS=$FREETYPE_LIBS" >&6;}
62879 62862
62880 62863
62881 62864 # Print a helpful message on how to acquire the necessary build dependency.
62882 62865 # freetype is the help tag: freetype, cups, alsa etc
62883 62866 MISSING_DEPENDENCY=freetype
62884 62867
62885 62868 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
62886 62869 cygwin_help $MISSING_DEPENDENCY
62887 62870 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
62888 62871 msys_help $MISSING_DEPENDENCY
62889 62872 else
62890 62873 PKGHANDLER_COMMAND=
62891 62874
62892 62875 case $PKGHANDLER in
62893 62876 apt-get)
62894 62877 apt_help $MISSING_DEPENDENCY ;;
62895 62878 yum)
62896 62879 yum_help $MISSING_DEPENDENCY ;;
62897 62880 port)
62898 62881 port_help $MISSING_DEPENDENCY ;;
62899 62882 pkgutil)
62900 62883 pkgutil_help $MISSING_DEPENDENCY ;;
62901 62884 pkgadd)
62902 62885 pkgadd_help $MISSING_DEPENDENCY ;;
62903 62886 esac
62904 62887
62905 62888 if test "x$PKGHANDLER_COMMAND" != x; then
62906 62889 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
62907 62890 fi
62908 62891 fi
62909 62892
62910 62893
62911 62894 as_fn_error $? "Can not continue without freetype. $HELP_MSG" "$LINENO" 5
62912 62895
62913 62896
62914 62897 fi
62915 62898 rm -f core conftest.err conftest.$ac_objext \
62916 62899 conftest$ac_exeext conftest.$ac_ext
62917 62900 CXXCFLAGS="$PREV_CXXFLAGS"
62918 62901 LIBS="$PREV_LIBS"
62919 62902 CXX="$PREV_CXX"
62920 62903 ac_ext=cpp
62921 62904 ac_cpp='$CXXCPP $CPPFLAGS'
62922 62905 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
62923 62906 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
62924 62907 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
62925 62908
62926 62909
62927 62910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should bundle freetype" >&5
62928 62911 $as_echo_n "checking if we should bundle freetype... " >&6; }
62929 62912 if test "x$BUNDLE_FREETYPE" = xyes; then
62930 62913 FREETYPE_BUNDLE_LIB_PATH="$FREETYPE_LIB_PATH"
62931 62914 fi
62932 62915 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUNDLE_FREETYPE" >&5
62933 62916 $as_echo "$BUNDLE_FREETYPE" >&6; }
62934 62917
62935 62918 fi # end freetype needed
62936 62919
62937 62920
62938 62921
62939 62922
62940 62923
62941 62924
62942 62925
62943 62926 # Check whether --with-alsa was given.
62944 62927 if test "${with_alsa+set}" = set; then :
62945 62928 withval=$with_alsa;
62946 62929 fi
62947 62930
62948 62931
62949 62932 # Check whether --with-alsa-include was given.
62950 62933 if test "${with_alsa_include+set}" = set; then :
62951 62934 withval=$with_alsa_include;
62952 62935 fi
62953 62936
62954 62937
62955 62938 # Check whether --with-alsa-lib was given.
62956 62939 if test "${with_alsa_lib+set}" = set; then :
62957 62940 withval=$with_alsa_lib;
62958 62941 fi
62959 62942
62960 62943
62961 62944 if test "x$NEEDS_LIB_ALSA" = xfalse; then
62962 62945 if (test "x${with_alsa}" != x && test "x${with_alsa}" != xno) || \
62963 62946 (test "x${with_alsa_include}" != x && test "x${with_alsa_include}" != xno) || \
62964 62947 (test "x${with_alsa_lib}" != x && test "x${with_alsa_lib}" != xno); then
62965 62948 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa[-*] is ignored" >&5
62966 62949 $as_echo "$as_me: WARNING: alsa not used, so --with-alsa[-*] is ignored" >&2;}
62967 62950 fi
62968 62951 ALSA_CFLAGS=
62969 62952 ALSA_LIBS=
62970 62953 else
62971 62954 ALSA_FOUND=no
62972 62955
62973 62956 if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then
62974 62957 as_fn_error $? "It is not possible to disable the use of alsa. Remove the --without-alsa option." "$LINENO" 5
62975 62958 fi
62976 62959
62977 62960 if test "x${with_alsa}" != x; then
62978 62961 ALSA_LIBS="-L${with_alsa}/lib -lasound"
62979 62962 ALSA_CFLAGS="-I${with_alsa}/include"
62980 62963 ALSA_FOUND=yes
62981 62964 fi
62982 62965 if test "x${with_alsa_include}" != x; then
62983 62966 ALSA_CFLAGS="-I${with_alsa_include}"
62984 62967 ALSA_FOUND=yes
62985 62968 fi
62986 62969 if test "x${with_alsa_lib}" != x; then
62987 62970 ALSA_LIBS="-L${with_alsa_lib} -lasound"
62988 62971 ALSA_FOUND=yes
62989 62972 fi
62990 62973 # Do not try pkg-config if we have a sysroot set.
62991 62974 if test "x$SYSROOT" = x; then
62992 62975 if test "x$ALSA_FOUND" = xno; then
62993 62976
62994 62977 pkg_failed=no
62995 62978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
62996 62979 $as_echo_n "checking for ALSA... " >&6; }
62997 62980
62998 62981 if test -n "$ALSA_CFLAGS"; then
62999 62982 pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS"
63000 62983 elif test -n "$PKG_CONFIG"; then
63001 62984 if test -n "$PKG_CONFIG" && \
63002 62985 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
63003 62986 ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
63004 62987 ac_status=$?
63005 62988 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63006 62989 test $ac_status = 0; }; then
63007 62990 pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null`
63008 62991 else
63009 62992 pkg_failed=yes
63010 62993 fi
63011 62994 else
63012 62995 pkg_failed=untried
63013 62996 fi
63014 62997 if test -n "$ALSA_LIBS"; then
63015 62998 pkg_cv_ALSA_LIBS="$ALSA_LIBS"
63016 62999 elif test -n "$PKG_CONFIG"; then
63017 63000 if test -n "$PKG_CONFIG" && \
63018 63001 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
63019 63002 ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
63020 63003 ac_status=$?
63021 63004 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63022 63005 test $ac_status = 0; }; then
63023 63006 pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null`
63024 63007 else
63025 63008 pkg_failed=yes
63026 63009 fi
63027 63010 else
63028 63011 pkg_failed=untried
63029 63012 fi
63030 63013
63031 63014
63032 63015
63033 63016 if test $pkg_failed = yes; then
63034 63017
63035 63018 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
63036 63019 _pkg_short_errors_supported=yes
63037 63020 else
63038 63021 _pkg_short_errors_supported=no
63039 63022 fi
63040 63023 if test $_pkg_short_errors_supported = yes; then
63041 63024 ALSA_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "alsa" 2>&1`
63042 63025 else
63043 63026 ALSA_PKG_ERRORS=`$PKG_CONFIG --print-errors "alsa" 2>&1`
63044 63027 fi
63045 63028 # Put the nasty error message in config.log where it belongs
63046 63029 echo "$ALSA_PKG_ERRORS" >&5
63047 63030
63048 63031 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
63049 63032 $as_echo "no" >&6; }
63050 63033 ALSA_FOUND=no
63051 63034 elif test $pkg_failed = untried; then
63052 63035 ALSA_FOUND=no
63053 63036 else
63054 63037 ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS
63055 63038 ALSA_LIBS=$pkg_cv_ALSA_LIBS
63056 63039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
63057 63040 $as_echo "yes" >&6; }
63058 63041 ALSA_FOUND=yes
63059 63042 fi
63060 63043 fi
63061 63044 fi
63062 63045 if test "x$ALSA_FOUND" = xno; then
63063 63046 for ac_header in alsa/asoundlib.h
63064 63047 do :
63065 63048 ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
63066 63049 if test "x$ac_cv_header_alsa_asoundlib_h" = xyes; then :
63067 63050 cat >>confdefs.h <<_ACEOF
63068 63051 #define HAVE_ALSA_ASOUNDLIB_H 1
63069 63052 _ACEOF
63070 63053
63071 63054 ALSA_FOUND=yes
63072 63055 ALSA_CFLAGS=-Iignoreme
63073 63056 ALSA_LIBS=-lasound
63074 63057 DEFAULT_ALSA=yes
63075 63058
63076 63059 else
63077 63060 ALSA_FOUND=no
63078 63061
63079 63062 fi
63080 63063
63081 63064 done
63082 63065
63083 63066 fi
63084 63067 if test "x$ALSA_FOUND" = xno; then
63085 63068
63086 63069 # Print a helpful message on how to acquire the necessary build dependency.
63087 63070 # alsa is the help tag: freetype, cups, alsa etc
63088 63071 MISSING_DEPENDENCY=alsa
63089 63072
63090 63073 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
63091 63074 cygwin_help $MISSING_DEPENDENCY
63092 63075 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
63093 63076 msys_help $MISSING_DEPENDENCY
63094 63077 else
63095 63078 PKGHANDLER_COMMAND=
63096 63079
63097 63080 case $PKGHANDLER in
63098 63081 apt-get)
63099 63082 apt_help $MISSING_DEPENDENCY ;;
63100 63083 yum)
63101 63084 yum_help $MISSING_DEPENDENCY ;;
63102 63085 port)
63103 63086 port_help $MISSING_DEPENDENCY ;;
63104 63087 pkgutil)
63105 63088 pkgutil_help $MISSING_DEPENDENCY ;;
63106 63089 pkgadd)
63107 63090 pkgadd_help $MISSING_DEPENDENCY ;;
63108 63091 esac
63109 63092
63110 63093 if test "x$PKGHANDLER_COMMAND" != x; then
63111 63094 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
63112 63095 fi
63113 63096 fi
63114 63097
63115 63098 as_fn_error $? "Could not find alsa! $HELP_MSG" "$LINENO" 5
63116 63099 fi
63117 63100 fi
63118 63101
63119 63102
63120 63103
63121 63104
63122 63105
63123 63106
63124 63107 # Check whether --with-libffi was given.
63125 63108 if test "${with_libffi+set}" = set; then :
63126 63109 withval=$with_libffi;
63127 63110 fi
63128 63111
63129 63112
63130 63113 # Check whether --with-libffi-include was given.
63131 63114 if test "${with_libffi_include+set}" = set; then :
63132 63115 withval=$with_libffi_include;
63133 63116 fi
63134 63117
63135 63118
63136 63119 # Check whether --with-libffi-lib was given.
63137 63120 if test "${with_libffi_lib+set}" = set; then :
63138 63121 withval=$with_libffi_lib;
63139 63122 fi
63140 63123
63141 63124
63142 63125 if test "x$NEEDS_LIB_FFI" = xfalse; then
63143 63126 if (test "x${with_libffi}" != x && test "x${with_libffi}" != xno) || \
63144 63127 (test "x${with_libffi_include}" != x && test "x${with_libffi_include}" != xno) || \
63145 63128 (test "x${with_libffi_lib}" != x && test "x${with_libffi_lib}" != xno); then
63146 63129 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: libffi not used, so --with-libffi[-*] is ignored" >&5
63147 63130 $as_echo "$as_me: WARNING: libffi not used, so --with-libffi[-*] is ignored" >&2;}
63148 63131 fi
63149 63132 LIBFFI_CFLAGS=
63150 63133 LIBFFI_LIBS=
63151 63134 else
63152 63135 LIBFFI_FOUND=no
63153 63136
63154 63137 if test "x${with_libffi}" = xno || test "x${with_libffi_include}" = xno || test "x${with_libffi_lib}" = xno; then
63155 63138 as_fn_error $? "It is not possible to disable the use of libffi. Remove the --without-libffi option." "$LINENO" 5
63156 63139 fi
63157 63140
63158 63141 if test "x${with_libffi}" != x; then
63159 63142 LIBFFI_LIBS="-L${with_libffi}/lib -lffi"
63160 63143 LIBFFI_CFLAGS="-I${with_libffi}/include"
63161 63144 LIBFFI_FOUND=yes
63162 63145 fi
63163 63146 if test "x${with_libffi_include}" != x; then
63164 63147 LIBFFI_CFLAGS="-I${with_libffi_include}"
63165 63148 LIBFFI_FOUND=yes
63166 63149 fi
63167 63150 if test "x${with_libffi_lib}" != x; then
63168 63151 LIBFFI_LIBS="-L${with_libffi_lib} -lffi"
63169 63152 LIBFFI_FOUND=yes
63170 63153 fi
63171 63154 # Do not try pkg-config if we have a sysroot set.
63172 63155 if test "x$SYSROOT" = x; then
63173 63156 if test "x$LIBFFI_FOUND" = xno; then
63174 63157 # Figure out LIBFFI_CFLAGS and LIBFFI_LIBS
63175 63158
63176 63159 pkg_failed=no
63177 63160 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
63178 63161 $as_echo_n "checking for LIBFFI... " >&6; }
63179 63162
63180 63163 if test -n "$LIBFFI_CFLAGS"; then
63181 63164 pkg_cv_LIBFFI_CFLAGS="$LIBFFI_CFLAGS"
63182 63165 elif test -n "$PKG_CONFIG"; then
63183 63166 if test -n "$PKG_CONFIG" && \
63184 63167 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
63185 63168 ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
63186 63169 ac_status=$?
63187 63170 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63188 63171 test $ac_status = 0; }; then
63189 63172 pkg_cv_LIBFFI_CFLAGS=`$PKG_CONFIG --cflags "libffi" 2>/dev/null`
63190 63173 else
63191 63174 pkg_failed=yes
63192 63175 fi
63193 63176 else
63194 63177 pkg_failed=untried
63195 63178 fi
63196 63179 if test -n "$LIBFFI_LIBS"; then
63197 63180 pkg_cv_LIBFFI_LIBS="$LIBFFI_LIBS"
63198 63181 elif test -n "$PKG_CONFIG"; then
63199 63182 if test -n "$PKG_CONFIG" && \
63200 63183 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
63201 63184 ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
63202 63185 ac_status=$?
63203 63186 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63204 63187 test $ac_status = 0; }; then
63205 63188 pkg_cv_LIBFFI_LIBS=`$PKG_CONFIG --libs "libffi" 2>/dev/null`
63206 63189 else
63207 63190 pkg_failed=yes
63208 63191 fi
63209 63192 else
63210 63193 pkg_failed=untried
63211 63194 fi
63212 63195
63213 63196
63214 63197
63215 63198 if test $pkg_failed = yes; then
63216 63199
63217 63200 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
63218 63201 _pkg_short_errors_supported=yes
63219 63202 else
63220 63203 _pkg_short_errors_supported=no
63221 63204 fi
63222 63205 if test $_pkg_short_errors_supported = yes; then
63223 63206 LIBFFI_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libffi" 2>&1`
63224 63207 else
63225 63208 LIBFFI_PKG_ERRORS=`$PKG_CONFIG --print-errors "libffi" 2>&1`
63226 63209 fi
63227 63210 # Put the nasty error message in config.log where it belongs
63228 63211 echo "$LIBFFI_PKG_ERRORS" >&5
63229 63212
63230 63213 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
63231 63214 $as_echo "no" >&6; }
63232 63215 LIBFFI_FOUND=no
63233 63216 elif test $pkg_failed = untried; then
63234 63217 LIBFFI_FOUND=no
63235 63218 else
63236 63219 LIBFFI_CFLAGS=$pkg_cv_LIBFFI_CFLAGS
63237 63220 LIBFFI_LIBS=$pkg_cv_LIBFFI_LIBS
63238 63221 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
63239 63222 $as_echo "yes" >&6; }
63240 63223 LIBFFI_FOUND=yes
63241 63224 fi
63242 63225 fi
63243 63226 fi
63244 63227 if test "x$LIBFFI_FOUND" = xno; then
63245 63228 for ac_header in ffi.h
63246 63229 do :
63247 63230 ac_fn_cxx_check_header_mongrel "$LINENO" "ffi.h" "ac_cv_header_ffi_h" "$ac_includes_default"
63248 63231 if test "x$ac_cv_header_ffi_h" = xyes; then :
63249 63232 cat >>confdefs.h <<_ACEOF
63250 63233 #define HAVE_FFI_H 1
63251 63234 _ACEOF
63252 63235
63253 63236 LIBFFI_FOUND=yes
63254 63237 LIBFFI_CFLAGS=
63255 63238 LIBFFI_LIBS=-lffi
63256 63239
63257 63240 else
63258 63241 LIBFFI_FOUND=no
63259 63242
63260 63243 fi
63261 63244
63262 63245 done
63263 63246
63264 63247 fi
63265 63248 if test "x$LIBFFI_FOUND" = xno; then
63266 63249
63267 63250 # Print a helpful message on how to acquire the necessary build dependency.
63268 63251 # ffi is the help tag: freetype, cups, alsa etc
63269 63252 MISSING_DEPENDENCY=ffi
63270 63253
63271 63254 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
63272 63255 cygwin_help $MISSING_DEPENDENCY
63273 63256 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
63274 63257 msys_help $MISSING_DEPENDENCY
63275 63258 else
63276 63259 PKGHANDLER_COMMAND=
63277 63260
63278 63261 case $PKGHANDLER in
63279 63262 apt-get)
63280 63263 apt_help $MISSING_DEPENDENCY ;;
63281 63264 yum)
63282 63265 yum_help $MISSING_DEPENDENCY ;;
63283 63266 port)
63284 63267 port_help $MISSING_DEPENDENCY ;;
63285 63268 pkgutil)
63286 63269 pkgutil_help $MISSING_DEPENDENCY ;;
63287 63270 pkgadd)
63288 63271 pkgadd_help $MISSING_DEPENDENCY ;;
63289 63272 esac
63290 63273
63291 63274 if test "x$PKGHANDLER_COMMAND" != x; then
63292 63275 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
63293 63276 fi
63294 63277 fi
63295 63278
63296 63279 as_fn_error $? "Could not find libffi! $HELP_MSG" "$LINENO" 5
63297 63280 fi
63298 63281
63299 63282 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libffi works" >&5
63300 63283 $as_echo_n "checking if libffi works... " >&6; }
63301 63284 ac_ext=c
63302 63285 ac_cpp='$CPP $CPPFLAGS'
63303 63286 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
63304 63287 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
63305 63288 ac_compiler_gnu=$ac_cv_c_compiler_gnu
63306 63289
63307 63290 OLD_CFLAGS="$CFLAGS"
63308 63291 CFLAGS="$CFLAGS $LIBFFI_CFLAGS"
63309 63292 OLD_LIBS="$LIBS"
63310 63293 LIBS="$LIBS $LIBFFI_LIBS"
63311 63294 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
63312 63295 /* end confdefs.h. */
63313 63296 #include <ffi.h>
63314 63297 int
63315 63298 main ()
63316 63299 {
63317 63300
63318 63301 ffi_call(NULL, NULL, NULL, NULL);
63319 63302 return 0;
63320 63303
63321 63304 ;
63322 63305 return 0;
63323 63306 }
63324 63307 _ACEOF
63325 63308 if ac_fn_c_try_link "$LINENO"; then :
63326 63309 LIBFFI_WORKS=yes
63327 63310 else
63328 63311 LIBFFI_WORKS=no
63329 63312
63330 63313 fi
63331 63314 rm -f core conftest.err conftest.$ac_objext \
63332 63315 conftest$ac_exeext conftest.$ac_ext
63333 63316 CFLAGS="$OLD_CFLAGS"
63334 63317 LIBS="$OLD_LIBS"
63335 63318 ac_ext=cpp
63336 63319 ac_cpp='$CXXCPP $CPPFLAGS'
63337 63320 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
63338 63321 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
63339 63322 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
63340 63323
63341 63324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBFFI_WORKS" >&5
63342 63325 $as_echo "$LIBFFI_WORKS" >&6; }
63343 63326
63344 63327 if test "x$LIBFFI_WORKS" = xno; then
63345 63328
63346 63329 # Print a helpful message on how to acquire the necessary build dependency.
63347 63330 # ffi is the help tag: freetype, cups, alsa etc
63348 63331 MISSING_DEPENDENCY=ffi
63349 63332
63350 63333 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
63351 63334 cygwin_help $MISSING_DEPENDENCY
63352 63335 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
63353 63336 msys_help $MISSING_DEPENDENCY
63354 63337 else
63355 63338 PKGHANDLER_COMMAND=
63356 63339
63357 63340 case $PKGHANDLER in
63358 63341 apt-get)
63359 63342 apt_help $MISSING_DEPENDENCY ;;
63360 63343 yum)
63361 63344 yum_help $MISSING_DEPENDENCY ;;
63362 63345 port)
63363 63346 port_help $MISSING_DEPENDENCY ;;
63364 63347 pkgutil)
63365 63348 pkgutil_help $MISSING_DEPENDENCY ;;
63366 63349 pkgadd)
63367 63350 pkgadd_help $MISSING_DEPENDENCY ;;
63368 63351 esac
63369 63352
63370 63353 if test "x$PKGHANDLER_COMMAND" != x; then
63371 63354 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
63372 63355 fi
63373 63356 fi
63374 63357
63375 63358 as_fn_error $? "Found libffi but could not link and compile with it. $HELP_MSG" "$LINENO" 5
63376 63359 fi
63377 63360 fi
63378 63361
63379 63362
63380 63363
63381 63364
63382 63365
63383 63366 if [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
63384 63367 # Extract the first word of "llvm-config", so it can be a program name with args.
63385 63368 set dummy llvm-config; ac_word=$2
63386 63369 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
63387 63370 $as_echo_n "checking for $ac_word... " >&6; }
63388 63371 if ${ac_cv_prog_LLVM_CONFIG+:} false; then :
63389 63372 $as_echo_n "(cached) " >&6
63390 63373 else
63391 63374 if test -n "$LLVM_CONFIG"; then
63392 63375 ac_cv_prog_LLVM_CONFIG="$LLVM_CONFIG" # Let the user override the test.
63393 63376 else
63394 63377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
63395 63378 for as_dir in $PATH
63396 63379 do
63397 63380 IFS=$as_save_IFS
63398 63381 test -z "$as_dir" && as_dir=.
63399 63382 for ac_exec_ext in '' $ac_executable_extensions; do
63400 63383 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
63401 63384 ac_cv_prog_LLVM_CONFIG="llvm-config"
63402 63385 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
63403 63386 break 2
63404 63387 fi
63405 63388 done
63406 63389 done
63407 63390 IFS=$as_save_IFS
63408 63391
63409 63392 fi
63410 63393 fi
63411 63394 LLVM_CONFIG=$ac_cv_prog_LLVM_CONFIG
63412 63395 if test -n "$LLVM_CONFIG"; then
63413 63396 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
63414 63397 $as_echo "$LLVM_CONFIG" >&6; }
63415 63398 else
63416 63399 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
63417 63400 $as_echo "no" >&6; }
63418 63401 fi
63419 63402
63420 63403
63421 63404
63422 63405 if test "x$LLVM_CONFIG" != xllvm-config; then
63423 63406 as_fn_error $? "llvm-config not found in $PATH." "$LINENO" 5
63424 63407 fi
63425 63408
63426 63409 llvm_components="jit mcjit engine nativecodegen native"
63427 63410 unset LLVM_CFLAGS
63428 63411 for flag in $("$LLVM_CONFIG" --cxxflags); do
63429 63412 if echo "${flag}" | grep -q '^-[ID]'; then
63430 63413 if test "${flag}" != "-D_DEBUG" ; then
63431 63414 if test "${LLVM_CFLAGS}" != "" ; then
63432 63415 LLVM_CFLAGS="${LLVM_CFLAGS} "
63433 63416 fi
63434 63417 LLVM_CFLAGS="${LLVM_CFLAGS}${flag}"
63435 63418 fi
63436 63419 fi
63437 63420 done
63438 63421 llvm_version=$("${LLVM_CONFIG}" --version | $SED 's/\.//; s/svn.*//')
63439 63422 LLVM_CFLAGS="${LLVM_CFLAGS} -DSHARK_LLVM_VERSION=${llvm_version}"
63440 63423
63441 63424 unset LLVM_LDFLAGS
63442 63425 for flag in $("${LLVM_CONFIG}" --ldflags); do
63443 63426 if echo "${flag}" | grep -q '^-L'; then
63444 63427 if test "${LLVM_LDFLAGS}" != ""; then
63445 63428 LLVM_LDFLAGS="${LLVM_LDFLAGS} "
63446 63429 fi
63447 63430 LLVM_LDFLAGS="${LLVM_LDFLAGS}${flag}"
63448 63431 fi
63449 63432 done
63450 63433
63451 63434 unset LLVM_LIBS
63452 63435 for flag in $("${LLVM_CONFIG}" --libs ${llvm_components}); do
63453 63436 if echo "${flag}" | grep -q '^-l'; then
63454 63437 if test "${LLVM_LIBS}" != ""; then
63455 63438 LLVM_LIBS="${LLVM_LIBS} "
63456 63439 fi
63457 63440 LLVM_LIBS="${LLVM_LIBS}${flag}"
63458 63441 fi
63459 63442 done
63460 63443
63461 63444 # Due to https://llvm.org/bugs/show_bug.cgi?id=16902, llvm does not
63462 63445 # always properly detect -ltinfo
63463 63446 LLVM_LIBS="${LLVM_LIBS} -ltinfo"
63464 63447
63465 63448
63466 63449
63467 63450
63468 63451 fi
63469 63452
63470 63453
63471 63454
63472 63455 # Check whether --with-libjpeg was given.
63473 63456 if test "${with_libjpeg+set}" = set; then :
63474 63457 withval=$with_libjpeg;
63475 63458 fi
63476 63459
63477 63460
63478 63461 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which libjpeg to use" >&5
63479 63462 $as_echo_n "checking for which libjpeg to use... " >&6; }
63480 63463 # default is bundled
63481 63464 DEFAULT_LIBJPEG=bundled
63482 63465 # if user didn't specify, use DEFAULT_LIBJPEG
63483 63466 if test "x${with_libjpeg}" = "x"; then
63484 63467 with_libjpeg=${DEFAULT_LIBJPEG}
63485 63468 fi
63486 63469 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_libjpeg}" >&5
63487 63470 $as_echo "${with_libjpeg}" >&6; }
63488 63471
63489 63472 if test "x${with_libjpeg}" = "xbundled"; then
63490 63473 USE_EXTERNAL_LIBJPEG=false
63491 63474 elif test "x${with_libjpeg}" = "xsystem"; then
63492 63475 ac_fn_cxx_check_header_mongrel "$LINENO" "jpeglib.h" "ac_cv_header_jpeglib_h" "$ac_includes_default"
63493 63476 if test "x$ac_cv_header_jpeglib_h" = xyes; then :
63494 63477
63495 63478 else
63496 63479 as_fn_error $? "--with-libjpeg=system specified, but jpeglib.h not found!" "$LINENO" 5
63497 63480 fi
63498 63481
63499 63482
63500 63483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jpeg_CreateDecompress in -ljpeg" >&5
63501 63484 $as_echo_n "checking for jpeg_CreateDecompress in -ljpeg... " >&6; }
63502 63485 if ${ac_cv_lib_jpeg_jpeg_CreateDecompress+:} false; then :
63503 63486 $as_echo_n "(cached) " >&6
63504 63487 else
63505 63488 ac_check_lib_save_LIBS=$LIBS
63506 63489 LIBS="-ljpeg $LIBS"
63507 63490 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
63508 63491 /* end confdefs.h. */
63509 63492
63510 63493 /* Override any GCC internal prototype to avoid an error.
63511 63494 Use char because int might match the return type of a GCC
63512 63495 builtin and then its argument prototype would still apply. */
63513 63496 #ifdef __cplusplus
63514 63497 extern "C"
63515 63498 #endif
63516 63499 char jpeg_CreateDecompress ();
63517 63500 int
63518 63501 main ()
63519 63502 {
63520 63503 return jpeg_CreateDecompress ();
63521 63504 ;
63522 63505 return 0;
63523 63506 }
63524 63507 _ACEOF
63525 63508 if ac_fn_cxx_try_link "$LINENO"; then :
63526 63509 ac_cv_lib_jpeg_jpeg_CreateDecompress=yes
63527 63510 else
63528 63511 ac_cv_lib_jpeg_jpeg_CreateDecompress=no
63529 63512 fi
63530 63513 rm -f core conftest.err conftest.$ac_objext \
63531 63514 conftest$ac_exeext conftest.$ac_ext
63532 63515 LIBS=$ac_check_lib_save_LIBS
63533 63516 fi
63534 63517 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_jpeg_CreateDecompress" >&5
63535 63518 $as_echo "$ac_cv_lib_jpeg_jpeg_CreateDecompress" >&6; }
63536 63519 if test "x$ac_cv_lib_jpeg_jpeg_CreateDecompress" = xyes; then :
63537 63520 cat >>confdefs.h <<_ACEOF
63538 63521 #define HAVE_LIBJPEG 1
63539 63522 _ACEOF
63540 63523
63541 63524 LIBS="-ljpeg $LIBS"
63542 63525
63543 63526 else
63544 63527 as_fn_error $? "--with-libjpeg=system specified, but no libjpeg found" "$LINENO" 5
63545 63528 fi
63546 63529
63547 63530
63548 63531 USE_EXTERNAL_LIBJPEG=true
63549 63532 else
63550 63533 as_fn_error $? "Invalid use of --with-libjpeg: ${with_libjpeg}, use 'system' or 'bundled'" "$LINENO" 5
63551 63534 fi
63552 63535
63553 63536
63554 63537
63555 63538
63556 63539
63557 63540 # Check whether --with-giflib was given.
63558 63541 if test "${with_giflib+set}" = set; then :
63559 63542 withval=$with_giflib;
63560 63543 fi
63561 63544
63562 63545
63563 63546 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
63564 63547 $as_echo_n "checking for which giflib to use... " >&6; }
63565 63548 # default is bundled
63566 63549 DEFAULT_GIFLIB=bundled
63567 63550 # if user didn't specify, use DEFAULT_GIFLIB
63568 63551 if test "x${with_giflib}" = "x"; then
63569 63552 with_giflib=${DEFAULT_GIFLIB}
63570 63553 fi
63571 63554 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
63572 63555 $as_echo "${with_giflib}" >&6; }
63573 63556
63574 63557 if test "x${with_giflib}" = "xbundled"; then
63575 63558 USE_EXTERNAL_LIBGIF=false
63576 63559 elif test "x${with_giflib}" = "xsystem"; then
63577 63560 ac_fn_cxx_check_header_mongrel "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
63578 63561 if test "x$ac_cv_header_gif_lib_h" = xyes; then :
63579 63562
63580 63563 else
63581 63564 as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5
63582 63565 fi
63583 63566
63584 63567
63585 63568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
63586 63569 $as_echo_n "checking for DGifGetCode in -lgif... " >&6; }
63587 63570 if ${ac_cv_lib_gif_DGifGetCode+:} false; then :
63588 63571 $as_echo_n "(cached) " >&6
63589 63572 else
63590 63573 ac_check_lib_save_LIBS=$LIBS
63591 63574 LIBS="-lgif $LIBS"
63592 63575 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
63593 63576 /* end confdefs.h. */
63594 63577
63595 63578 /* Override any GCC internal prototype to avoid an error.
63596 63579 Use char because int might match the return type of a GCC
63597 63580 builtin and then its argument prototype would still apply. */
63598 63581 #ifdef __cplusplus
63599 63582 extern "C"
63600 63583 #endif
63601 63584 char DGifGetCode ();
63602 63585 int
63603 63586 main ()
63604 63587 {
63605 63588 return DGifGetCode ();
63606 63589 ;
63607 63590 return 0;
63608 63591 }
63609 63592 _ACEOF
63610 63593 if ac_fn_cxx_try_link "$LINENO"; then :
63611 63594 ac_cv_lib_gif_DGifGetCode=yes
63612 63595 else
63613 63596 ac_cv_lib_gif_DGifGetCode=no
63614 63597 fi
63615 63598 rm -f core conftest.err conftest.$ac_objext \
63616 63599 conftest$ac_exeext conftest.$ac_ext
63617 63600 LIBS=$ac_check_lib_save_LIBS
63618 63601 fi
63619 63602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
63620 63603 $as_echo "$ac_cv_lib_gif_DGifGetCode" >&6; }
63621 63604 if test "x$ac_cv_lib_gif_DGifGetCode" = xyes; then :
63622 63605 cat >>confdefs.h <<_ACEOF
63623 63606 #define HAVE_LIBGIF 1
63624 63607 _ACEOF
63625 63608
63626 63609 LIBS="-lgif $LIBS"
63627 63610
63628 63611 else
63629 63612 as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5
63630 63613 fi
63631 63614
63632 63615
63633 63616 USE_EXTERNAL_LIBGIF=true
63634 63617 else
63635 63618 as_fn_error $? "Invalid value of --with-giflib: ${with_giflib}, use 'system' or 'bundled'" "$LINENO" 5
63636 63619 fi
63637 63620
63638 63621
63639 63622
63640 63623
63641 63624
63642 63625 # Check whether --with-libpng was given.
63643 63626 if test "${with_libpng+set}" = set; then :
63644 63627 withval=$with_libpng;
63645 63628 fi
63646 63629
63647 63630
63648 63631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which libpng to use" >&5
63649 63632 $as_echo_n "checking for which libpng to use... " >&6; }
63650 63633
63651 63634 # default is bundled
63652 63635 DEFAULT_LIBPNG=bundled
63653 63636 # if user didn't specify, use DEFAULT_LIBPNG
63654 63637 if test "x${with_libpng}" = "x"; then
63655 63638 with_libpng=${DEFAULT_LIBPNG}
63656 63639 fi
63657 63640
63658 63641 if test "x${with_libpng}" = "xbundled"; then
63659 63642 USE_EXTERNAL_LIBPNG=false
63660 63643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
63661 63644 $as_echo "bundled" >&6; }
63662 63645 elif test "x${with_libpng}" = "xsystem"; then
63663 63646
63664 63647 pkg_failed=no
63665 63648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PNG" >&5
63666 63649 $as_echo_n "checking for PNG... " >&6; }
63667 63650
63668 63651 if test -n "$PNG_CFLAGS"; then
63669 63652 pkg_cv_PNG_CFLAGS="$PNG_CFLAGS"
63670 63653 elif test -n "$PKG_CONFIG"; then
63671 63654 if test -n "$PKG_CONFIG" && \
63672 63655 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpng\""; } >&5
63673 63656 ($PKG_CONFIG --exists --print-errors "libpng") 2>&5
63674 63657 ac_status=$?
63675 63658 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63676 63659 test $ac_status = 0; }; then
63677 63660 pkg_cv_PNG_CFLAGS=`$PKG_CONFIG --cflags "libpng" 2>/dev/null`
63678 63661 else
63679 63662 pkg_failed=yes
63680 63663 fi
63681 63664 else
63682 63665 pkg_failed=untried
63683 63666 fi
63684 63667 if test -n "$PNG_LIBS"; then
63685 63668 pkg_cv_PNG_LIBS="$PNG_LIBS"
63686 63669 elif test -n "$PKG_CONFIG"; then
63687 63670 if test -n "$PKG_CONFIG" && \
63688 63671 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpng\""; } >&5
63689 63672 ($PKG_CONFIG --exists --print-errors "libpng") 2>&5
63690 63673 ac_status=$?
63691 63674 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63692 63675 test $ac_status = 0; }; then
63693 63676 pkg_cv_PNG_LIBS=`$PKG_CONFIG --libs "libpng" 2>/dev/null`
63694 63677 else
63695 63678 pkg_failed=yes
63696 63679 fi
63697 63680 else
63698 63681 pkg_failed=untried
63699 63682 fi
63700 63683
63701 63684
63702 63685
63703 63686 if test $pkg_failed = yes; then
63704 63687
63705 63688 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
63706 63689 _pkg_short_errors_supported=yes
63707 63690 else
63708 63691 _pkg_short_errors_supported=no
63709 63692 fi
63710 63693 if test $_pkg_short_errors_supported = yes; then
63711 63694 PNG_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libpng" 2>&1`
63712 63695 else
63713 63696 PNG_PKG_ERRORS=`$PKG_CONFIG --print-errors "libpng" 2>&1`
63714 63697 fi
63715 63698 # Put the nasty error message in config.log where it belongs
63716 63699 echo "$PNG_PKG_ERRORS" >&5
63717 63700
63718 63701 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
63719 63702 $as_echo "no" >&6; }
63720 63703 LIBPNG_FOUND=no
63721 63704 elif test $pkg_failed = untried; then
63722 63705 LIBPNG_FOUND=no
63723 63706 else
63724 63707 PNG_CFLAGS=$pkg_cv_PNG_CFLAGS
63725 63708 PNG_LIBS=$pkg_cv_PNG_LIBS
63726 63709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
63727 63710 $as_echo "yes" >&6; }
63728 63711 LIBPNG_FOUND=yes
63729 63712 fi
63730 63713 if test "x${LIBPNG_FOUND}" = "xyes"; then
63731 63714 USE_EXTERNAL_LIBPNG=true
63732 63715 { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
63733 63716 $as_echo "system" >&6; }
63734 63717 else
63735 63718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
63736 63719 $as_echo "system not found" >&6; }
63737 63720 as_fn_error $? "--with-libpng=system specified, but no libpng found!" "$LINENO" 5
63738 63721 fi
63739 63722 else
63740 63723 as_fn_error $? "Invalid value of --with-libpng: ${with_libpng}, use 'system' or 'bundled'" "$LINENO" 5
63741 63724 fi
63742 63725
63743 63726
63744 63727
63745 63728
63746 63729
63747 63730 # Check whether --with-zlib was given.
63748 63731 if test "${with_zlib+set}" = set; then :
63749 63732 withval=$with_zlib;
63750 63733 fi
63751 63734
63752 63735
63753 63736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
63754 63737 $as_echo_n "checking for compress in -lz... " >&6; }
63755 63738 if ${ac_cv_lib_z_compress+:} false; then :
63756 63739 $as_echo_n "(cached) " >&6
63757 63740 else
63758 63741 ac_check_lib_save_LIBS=$LIBS
63759 63742 LIBS="-lz $LIBS"
63760 63743 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
63761 63744 /* end confdefs.h. */
63762 63745
63763 63746 /* Override any GCC internal prototype to avoid an error.
63764 63747 Use char because int might match the return type of a GCC
63765 63748 builtin and then its argument prototype would still apply. */
63766 63749 #ifdef __cplusplus
63767 63750 extern "C"
63768 63751 #endif
63769 63752 char compress ();
63770 63753 int
63771 63754 main ()
63772 63755 {
63773 63756 return compress ();
63774 63757 ;
63775 63758 return 0;
63776 63759 }
63777 63760 _ACEOF
63778 63761 if ac_fn_cxx_try_link "$LINENO"; then :
63779 63762 ac_cv_lib_z_compress=yes
63780 63763 else
63781 63764 ac_cv_lib_z_compress=no
63782 63765 fi
63783 63766 rm -f core conftest.err conftest.$ac_objext \
63784 63767 conftest$ac_exeext conftest.$ac_ext
63785 63768 LIBS=$ac_check_lib_save_LIBS
63786 63769 fi
63787 63770 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
63788 63771 $as_echo "$ac_cv_lib_z_compress" >&6; }
63789 63772 if test "x$ac_cv_lib_z_compress" = xyes; then :
63790 63773 ZLIB_FOUND=yes
63791 63774 else
63792 63775 ZLIB_FOUND=no
63793 63776 fi
63794 63777
63795 63778
63796 63779 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
63797 63780 $as_echo_n "checking for which zlib to use... " >&6; }
63798 63781
63799 63782 DEFAULT_ZLIB=system
63800 63783 if test "x$OPENJDK_TARGET_OS" = xwindows; then
63801 63784 # On windows default is bundled...on others default is system
63802 63785 DEFAULT_ZLIB=bundled
63803 63786 fi
63804 63787
63805 63788 if test "x${ZLIB_FOUND}" != "xyes"; then
63806 63789 # If we don't find any system...set default to bundled
63807 63790 DEFAULT_ZLIB=bundled
63808 63791 fi
63809 63792
63810 63793 # If user didn't specify, use DEFAULT_ZLIB
63811 63794 if test "x${with_zlib}" = "x"; then
63812 63795 with_zlib=${DEFAULT_ZLIB}
63813 63796 fi
63814 63797
63815 63798 if test "x${with_zlib}" = "xbundled"; then
63816 63799 USE_EXTERNAL_LIBZ=false
63817 63800 { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
63818 63801 $as_echo "bundled" >&6; }
63819 63802 elif test "x${with_zlib}" = "xsystem"; then
63820 63803 if test "x${ZLIB_FOUND}" = "xyes"; then
63821 63804 USE_EXTERNAL_LIBZ=true
63822 63805 { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
63823 63806 $as_echo "system" >&6; }
63824 63807 else
63825 63808 { $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
63826 63809 $as_echo "system not found" >&6; }
63827 63810 as_fn_error $? "--with-zlib=system specified, but no zlib found!" "$LINENO" 5
63828 63811 fi
63829 63812 else
63830 63813 as_fn_error $? "Invalid value for --with-zlib: ${with_zlib}, use 'system' or 'bundled'" "$LINENO" 5
63831 63814 fi
63832 63815
63833 63816
63834 63817
63835 63818
63836 63819
63837 63820 # Check whether --with-lcms was given.
63838 63821 if test "${with_lcms+set}" = set; then :
63839 63822 withval=$with_lcms;
63840 63823 fi
63841 63824
63842 63825
63843 63826 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which lcms to use" >&5
63844 63827 $as_echo_n "checking for which lcms to use... " >&6; }
63845 63828
63846 63829 DEFAULT_LCMS=bundled
63847 63830 # If user didn't specify, use DEFAULT_LCMS
63848 63831 if test "x${with_lcms}" = "x"; then
63849 63832 with_lcms=${DEFAULT_LCMS}
63850 63833 fi
63851 63834
63852 63835 if test "x${with_lcms}" = "xbundled"; then
63853 63836 USE_EXTERNAL_LCMS=false
63854 63837 { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
63855 63838 $as_echo "bundled" >&6; }
63856 63839 elif test "x${with_lcms}" = "xsystem"; then
63857 63840 { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
63858 63841 $as_echo "system" >&6; }
63859 63842
63860 63843 pkg_failed=no
63861 63844 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LCMS" >&5
63862 63845 $as_echo_n "checking for LCMS... " >&6; }
63863 63846
63864 63847 if test -n "$LCMS_CFLAGS"; then
63865 63848 pkg_cv_LCMS_CFLAGS="$LCMS_CFLAGS"
63866 63849 elif test -n "$PKG_CONFIG"; then
63867 63850 if test -n "$PKG_CONFIG" && \
63868 63851 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"lcms2\""; } >&5
63869 63852 ($PKG_CONFIG --exists --print-errors "lcms2") 2>&5
63870 63853 ac_status=$?
63871 63854 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63872 63855 test $ac_status = 0; }; then
63873 63856 pkg_cv_LCMS_CFLAGS=`$PKG_CONFIG --cflags "lcms2" 2>/dev/null`
63874 63857 else
63875 63858 pkg_failed=yes
63876 63859 fi
63877 63860 else
63878 63861 pkg_failed=untried
63879 63862 fi
63880 63863 if test -n "$LCMS_LIBS"; then
63881 63864 pkg_cv_LCMS_LIBS="$LCMS_LIBS"
63882 63865 elif test -n "$PKG_CONFIG"; then
63883 63866 if test -n "$PKG_CONFIG" && \
63884 63867 { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"lcms2\""; } >&5
63885 63868 ($PKG_CONFIG --exists --print-errors "lcms2") 2>&5
63886 63869 ac_status=$?
63887 63870 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
63888 63871 test $ac_status = 0; }; then
63889 63872 pkg_cv_LCMS_LIBS=`$PKG_CONFIG --libs "lcms2" 2>/dev/null`
63890 63873 else
63891 63874 pkg_failed=yes
63892 63875 fi
63893 63876 else
63894 63877 pkg_failed=untried
63895 63878 fi
63896 63879
63897 63880
63898 63881
63899 63882 if test $pkg_failed = yes; then
63900 63883
63901 63884 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
63902 63885 _pkg_short_errors_supported=yes
63903 63886 else
63904 63887 _pkg_short_errors_supported=no
63905 63888 fi
63906 63889 if test $_pkg_short_errors_supported = yes; then
63907 63890 LCMS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "lcms2" 2>&1`
63908 63891 else
63909 63892 LCMS_PKG_ERRORS=`$PKG_CONFIG --print-errors "lcms2" 2>&1`
63910 63893 fi
63911 63894 # Put the nasty error message in config.log where it belongs
63912 63895 echo "$LCMS_PKG_ERRORS" >&5
63913 63896
63914 63897 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
63915 63898 $as_echo "no" >&6; }
63916 63899 LCMS_FOUND=no
63917 63900 elif test $pkg_failed = untried; then
63918 63901 LCMS_FOUND=no
63919 63902 else
63920 63903 LCMS_CFLAGS=$pkg_cv_LCMS_CFLAGS
63921 63904 LCMS_LIBS=$pkg_cv_LCMS_LIBS
63922 63905 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
63923 63906 $as_echo "yes" >&6; }
63924 63907 LCMS_FOUND=yes
63925 63908 fi
63926 63909 if test "x${LCMS_FOUND}" = "xyes"; then
63927 63910 USE_EXTERNAL_LCMS=true
63928 63911 else
63929 63912 as_fn_error $? "--with-lcms=system specified, but no lcms found!" "$LINENO" 5
63930 63913 fi
63931 63914 else
63932 63915 as_fn_error $? "Invalid value for --with-lcms: ${with_lcms}, use 'system' or 'bundled'" "$LINENO" 5
63933 63916 fi
63934 63917
63935 63918
63936 63919
63937 63920
63938 63921
63939 63922
63940 63923
63941 63924
63942 63925
63943 63926
63944 63927
63945 63928 # Setup libm (the maths library)
63946 63929 if test "x$OPENJDK_TARGET_OS" != "xwindows"; then
63947 63930 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
63948 63931 $as_echo_n "checking for cos in -lm... " >&6; }
63949 63932 if ${ac_cv_lib_m_cos+:} false; then :
63950 63933 $as_echo_n "(cached) " >&6
63951 63934 else
63952 63935 ac_check_lib_save_LIBS=$LIBS
63953 63936 LIBS="-lm $LIBS"
63954 63937 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
63955 63938 /* end confdefs.h. */
63956 63939
63957 63940 /* Override any GCC internal prototype to avoid an error.
63958 63941 Use char because int might match the return type of a GCC
63959 63942 builtin and then its argument prototype would still apply. */
63960 63943 #ifdef __cplusplus
63961 63944 extern "C"
63962 63945 #endif
63963 63946 char cos ();
63964 63947 int
63965 63948 main ()
63966 63949 {
63967 63950 return cos ();
63968 63951 ;
63969 63952 return 0;
63970 63953 }
63971 63954 _ACEOF
63972 63955 if ac_fn_cxx_try_link "$LINENO"; then :
63973 63956 ac_cv_lib_m_cos=yes
63974 63957 else
63975 63958 ac_cv_lib_m_cos=no
63976 63959 fi
63977 63960 rm -f core conftest.err conftest.$ac_objext \
63978 63961 conftest$ac_exeext conftest.$ac_ext
63979 63962 LIBS=$ac_check_lib_save_LIBS
63980 63963 fi
63981 63964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
63982 63965 $as_echo "$ac_cv_lib_m_cos" >&6; }
63983 63966 if test "x$ac_cv_lib_m_cos" = xyes; then :
63984 63967 cat >>confdefs.h <<_ACEOF
63985 63968 #define HAVE_LIBM 1
63986 63969 _ACEOF
63987 63970
63988 63971 LIBS="-lm $LIBS"
63989 63972
63990 63973 else
63991 63974
63992 63975 { $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
63993 63976 $as_echo "$as_me: Maths library was not found" >&6;}
63994 63977
63995 63978 fi
63996 63979
63997 63980 LIBM="-lm"
63998 63981 else
63999 63982 LIBM=""
64000 63983 fi
64001 63984
64002 63985
64003 63986 # Setup libdl (for dynamic library loading)
64004 63987 save_LIBS="$LIBS"
64005 63988 LIBS=""
64006 63989 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
64007 63990 $as_echo_n "checking for dlopen in -ldl... " >&6; }
64008 63991 if ${ac_cv_lib_dl_dlopen+:} false; then :
64009 63992 $as_echo_n "(cached) " >&6
64010 63993 else
64011 63994 ac_check_lib_save_LIBS=$LIBS
64012 63995 LIBS="-ldl $LIBS"
64013 63996 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
64014 63997 /* end confdefs.h. */
64015 63998
64016 63999 /* Override any GCC internal prototype to avoid an error.
64017 64000 Use char because int might match the return type of a GCC
64018 64001 builtin and then its argument prototype would still apply. */
64019 64002 #ifdef __cplusplus
64020 64003 extern "C"
64021 64004 #endif
64022 64005 char dlopen ();
64023 64006 int
64024 64007 main ()
64025 64008 {
64026 64009 return dlopen ();
64027 64010 ;
64028 64011 return 0;
64029 64012 }
64030 64013 _ACEOF
64031 64014 if ac_fn_cxx_try_link "$LINENO"; then :
64032 64015 ac_cv_lib_dl_dlopen=yes
64033 64016 else
64034 64017 ac_cv_lib_dl_dlopen=no
64035 64018 fi
64036 64019 rm -f core conftest.err conftest.$ac_objext \
64037 64020 conftest$ac_exeext conftest.$ac_ext
64038 64021 LIBS=$ac_check_lib_save_LIBS
64039 64022 fi
64040 64023 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
64041 64024 $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
64042 64025 if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
64043 64026 cat >>confdefs.h <<_ACEOF
64044 64027 #define HAVE_LIBDL 1
64045 64028 _ACEOF
64046 64029
64047 64030 LIBS="-ldl $LIBS"
64048 64031
64049 64032 fi
64050 64033
64051 64034 LIBDL="$LIBS"
64052 64035
64053 64036 LIBS="$save_LIBS"
64054 64037
64055 64038 # Deprecated libraries, keep the flags for backwards compatibility
64056 64039 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
64057 64040
64058 64041
64059 64042 # Check whether --with-dxsdk was given.
64060 64043 if test "${with_dxsdk+set}" = set; then :
64061 64044 withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
64062 64045 $as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
64063 64046 fi
64064 64047
64065 64048
64066 64049
64067 64050
64068 64051 # Check whether --with-dxsdk-lib was given.
64069 64052 if test "${with_dxsdk_lib+set}" = set; then :
64070 64053 withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
64071 64054 $as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
64072 64055 fi
64073 64056
64074 64057
64075 64058
64076 64059
64077 64060 # Check whether --with-dxsdk-include was given.
64078 64061 if test "${with_dxsdk_include+set}" = set; then :
64079 64062 withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
64080 64063 $as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
64081 64064 fi
64082 64065
64083 64066
64084 64067 fi
64085 64068
64086 64069 # Control if libzip can use mmap. Available for purposes of overriding.
64087 64070 LIBZIP_CAN_USE_MMAP=true
64088 64071
64089 64072
64090 64073
64091 64074 if test "$OPENJDK_TARGET_OS" = "solaris" && test "x$BUILD_GTEST" = "xtrue"; then
64092 64075 # Find the root of the Solaris Studio installation from the compiler path
64093 64076 SOLARIS_STUDIO_DIR="$(dirname $CC)/.."
64094 64077 STLPORT_LIB="$SOLARIS_STUDIO_DIR/lib/stlport4$OPENJDK_TARGET_CPU_ISADIR/libstlport.so.1"
64095 64078 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libstlport.so.1" >&5
64096 64079 $as_echo_n "checking for libstlport.so.1... " >&6; }
64097 64080 if ! test -f "$STLPORT_LIB" && test "x$OPENJDK_TARGET_CPU_ISADIR" = "x/sparcv9"; then
64098 64081 # SS12u3 has libstlport under 'stlport4/v9' instead of 'stlport4/sparcv9'
64099 64082 STLPORT_LIB="$SOLARIS_STUDIO_DIR/lib/stlport4/v9/libstlport.so.1"
64100 64083 fi
64101 64084 if test -f "$STLPORT_LIB"; then
64102 64085 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, $STLPORT_LIB" >&5
64103 64086 $as_echo "yes, $STLPORT_LIB" >&6; }
64104 64087
64105 64088 # Only process if variable expands to non-empty
64106 64089
64107 64090 if test "x$STLPORT_LIB" != x; then
64108 64091 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
64109 64092
64110 64093 # Input might be given as Windows format, start by converting to
64111 64094 # unix format.
64112 64095 path="$STLPORT_LIB"
64113 64096 new_path=`$CYGPATH -u "$path"`
64114 64097
64115 64098 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
64116 64099 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
64117 64100 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
64118 64101 # "foo.exe" is OK but "foo" is an error.
64119 64102 #
64120 64103 # This test is therefore slightly more accurate than "test -f" to check for file precense.
64121 64104 # It is also a way to make sure we got the proper file name for the real test later on.
64122 64105 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
64123 64106 if test "x$test_shortpath" = x; then
64124 64107 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&5
64125 64108 $as_echo "$as_me: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&6;}
64126 64109 as_fn_error $? "Cannot locate the the path of STLPORT_LIB" "$LINENO" 5
64127 64110 fi
64128 64111
64129 64112 # Call helper function which possibly converts this using DOS-style short mode.
64130 64113 # If so, the updated path is stored in $new_path.
64131 64114
64132 64115 input_path="$new_path"
64133 64116 # Check if we need to convert this using DOS-style short mode. If the path
64134 64117 # contains just simple characters, use it. Otherwise (spaces, weird characters),
64135 64118 # take no chances and rewrite it.
64136 64119 # Note: m4 eats our [], so we need to use [ and ] instead.
64137 64120 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
64138 64121 if test "x$has_forbidden_chars" != x; then
64139 64122 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
64140 64123 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
64141 64124 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
64142 64125 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
64143 64126 # Going to short mode and back again did indeed matter. Since short mode is
64144 64127 # case insensitive, let's make it lowercase to improve readability.
64145 64128 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
64146 64129 # Now convert it back to Unix-style (cygpath)
64147 64130 input_path=`$CYGPATH -u "$shortmode_path"`
64148 64131 new_path="$input_path"
64149 64132 fi
64150 64133 fi
64151 64134
64152 64135 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
64153 64136 if test "x$test_cygdrive_prefix" = x; then
64154 64137 # As a simple fix, exclude /usr/bin since it's not a real path.
64155 64138 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
64156 64139 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
64157 64140 # a path prefixed by /cygdrive for fixpath to work.
64158 64141 new_path="$CYGWIN_ROOT_PATH$input_path"
64159 64142 fi
64160 64143 fi
64161 64144
64162 64145
64163 64146 if test "x$path" != "x$new_path"; then
64164 64147 STLPORT_LIB="$new_path"
64165 64148 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STLPORT_LIB to \"$new_path\"" >&5
64166 64149 $as_echo "$as_me: Rewriting STLPORT_LIB to \"$new_path\"" >&6;}
64167 64150 fi
64168 64151
64169 64152 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
64170 64153
64171 64154 path="$STLPORT_LIB"
64172 64155 has_colon=`$ECHO $path | $GREP ^.:`
64173 64156 new_path="$path"
64174 64157 if test "x$has_colon" = x; then
64175 64158 # Not in mixed or Windows style, start by that.
64176 64159 new_path=`cmd //c echo $path`
64177 64160 fi
64178 64161
64179 64162
64180 64163 input_path="$new_path"
64181 64164 # Check if we need to convert this using DOS-style short mode. If the path
64182 64165 # contains just simple characters, use it. Otherwise (spaces, weird characters),
64183 64166 # take no chances and rewrite it.
64184 64167 # Note: m4 eats our [], so we need to use [ and ] instead.
64185 64168 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
64186 64169 if test "x$has_forbidden_chars" != x; then
64187 64170 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
64188 64171 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
64189 64172 fi
64190 64173
64191 64174
64192 64175 windows_path="$new_path"
64193 64176 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
64194 64177 unix_path=`$CYGPATH -u "$windows_path"`
64195 64178 new_path="$unix_path"
64196 64179 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
64197 64180 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
64198 64181 new_path="$unix_path"
64199 64182 fi
64200 64183
64201 64184 if test "x$path" != "x$new_path"; then
64202 64185 STLPORT_LIB="$new_path"
64203 64186 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STLPORT_LIB to \"$new_path\"" >&5
64204 64187 $as_echo "$as_me: Rewriting STLPORT_LIB to \"$new_path\"" >&6;}
64205 64188 fi
64206 64189
64207 64190 # Save the first 10 bytes of this path to the storage, so fixpath can work.
64208 64191 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
64209 64192
64210 64193 else
64211 64194 # We're on a unix platform. Hooray! :)
64212 64195 path="$STLPORT_LIB"
64213 64196 has_space=`$ECHO "$path" | $GREP " "`
64214 64197 if test "x$has_space" != x; then
64215 64198 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&5
64216 64199 $as_echo "$as_me: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&6;}
64217 64200 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
64218 64201 fi
64219 64202
64220 64203 # Use eval to expand a potential ~
64221 64204 eval path="$path"
64222 64205 if test ! -f "$path" && test ! -d "$path"; then
64223 64206 as_fn_error $? "The path of STLPORT_LIB, which resolves as \"$path\", is not found." "$LINENO" 5
64224 64207 fi
64225 64208
64226 64209 if test -d "$path"; then
64227 64210 STLPORT_LIB="`cd "$path"; $THEPWDCMD -L`"
64228 64211 else
64229 64212 dir="`$DIRNAME "$path"`"
64230 64213 base="`$BASENAME "$path"`"
64231 64214 STLPORT_LIB="`cd "$dir"; $THEPWDCMD -L`/$base"
64232 64215 fi
64233 64216 fi
64234 64217 fi
64235 64218
64236 64219 else
64237 64220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, not found at $STLPORT_LIB" >&5
64238 64221 $as_echo "no, not found at $STLPORT_LIB" >&6; }
64239 64222 as_fn_error $? "Failed to find libstlport.so.1, cannot build Hotspot gtests" "$LINENO" 5
64240 64223 fi
64241 64224
64242 64225 fi
64243 64226
64244 64227
64245 64228
64246 64229
64247 64230
64248 64231
64249 64232
64250 64233
64251 64234
64252 64235
64253 64236
64254 64237
64255 64238
64256 64239
64257 64240 ###############################################################################
64258 64241 #
64259 64242 # We need to do some final tweaking, when everything else is done.
64260 64243 #
64261 64244 ###############################################################################
64262 64245
64263 64246
64264 64247 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
64265 64248 $as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
64266 64249
64267 64250 if test -d "${SRC_ROOT}/jdk/src/jdk.crypto.ec/share/native/libsunec/impl"; then
64268 64251 ENABLE_INTREE_EC=yes
64269 64252 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
64270 64253 $as_echo "yes" >&6; }
64271 64254 else
64272 64255 ENABLE_INTREE_EC=no
64273 64256 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
64274 64257 $as_echo "no" >&6; }
64275 64258 fi
64276 64259
64277 64260
64278 64261
64279 64262
64280 64263 # Check whether --enable-jtreg-failure-handler was given.
64281 64264 if test "${enable_jtreg_failure_handler+set}" = set; then :
64282 64265 enableval=$enable_jtreg_failure_handler;
64283 64266 fi
64284 64267
64285 64268
64286 64269 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jtreg failure handler should be built" >&5
64287 64270 $as_echo_n "checking if jtreg failure handler should be built... " >&6; }
64288 64271
64289 64272 if test "x$enable_jtreg_failure_handler" = "xyes"; then
64290 64273 if test "x$JT_HOME" = "x"; then
64291 64274 as_fn_error $? "Cannot enable jtreg failure handler without jtreg." "$LINENO" 5
64292 64275 else
64293 64276 BUILD_FAILURE_HANDLER=true
64294 64277 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
64295 64278 $as_echo "yes, forced" >&6; }
64296 64279 fi
64297 64280 elif test "x$enable_jtreg_failure_handler" = "xno"; then
64298 64281 BUILD_FAILURE_HANDLER=false
64299 64282 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
64300 64283 $as_echo "no, forced" >&6; }
64301 64284 elif test "x$enable_jtreg_failure_handler" = "xauto" \
64302 64285 || test "x$enable_jtreg_failure_handler" = "x"; then
64303 64286 if test "x$JT_HOME" = "x"; then
64304 64287 BUILD_FAILURE_HANDLER=false
64305 64288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing jtreg" >&5
64306 64289 $as_echo "no, missing jtreg" >&6; }
64307 64290 else
64308 64291 BUILD_FAILURE_HANDLER=true
64309 64292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, jtreg present" >&5
64310 64293 $as_echo "yes, jtreg present" >&6; }
64311 64294 fi
64312 64295 else
64313 64296 as_fn_error $? "Invalid value for --enable-jtreg-failure-handler: $enable_jtreg_failure_handler" "$LINENO" 5
64314 64297 fi
64315 64298
64316 64299
64317 64300
64318 64301
64319 64302 # Check whether --enable-generate-classlist was given.
64320 64303 if test "${enable_generate_classlist+set}" = set; then :
64321 64304 enableval=$enable_generate_classlist;
64322 64305 fi
64323 64306
64324 64307
64325 64308 # Check if it's likely that it's possible to generate the classlist. Depending
64326 64309 # on exact jvm configuration it could be possible anyway.
64327 64310 if [[ " $JVM_VARIANTS " =~ " server " ]] || [[ " $JVM_VARIANTS " =~ " client " ]] ; then
64328 64311 ENABLE_GENERATE_CLASSLIST_POSSIBLE="true"
64329 64312 else
64330 64313 ENABLE_GENERATE_CLASSLIST_POSSIBLE="false"
64331 64314 fi
64332 64315
64333 64316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the CDS classlist generation should be enabled" >&5
64334 64317 $as_echo_n "checking if the CDS classlist generation should be enabled... " >&6; }
64335 64318 if test "x$enable_generate_classlist" = "xyes"; then
64336 64319 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
64337 64320 $as_echo "yes, forced" >&6; }
64338 64321 ENABLE_GENERATE_CLASSLIST="true"
64339 64322 if test "x$ENABLE_GENERATE_CLASSLIST_POSSIBLE" = "xfalse"; then
64340 64323 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Generation of classlist might not be possible with JVM Variants $JVM_VARIANTS" >&5
64341 64324 $as_echo "$as_me: WARNING: Generation of classlist might not be possible with JVM Variants $JVM_VARIANTS" >&2;}
64342 64325 fi
64343 64326 elif test "x$enable_generate_classlist" = "xno"; then
64344 64327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
64345 64328 $as_echo "no, forced" >&6; }
64346 64329 ENABLE_GENERATE_CLASSLIST="false"
64347 64330 elif test "x$enable_generate_classlist" = "x"; then
64348 64331 if test "x$ENABLE_GENERATE_CLASSLIST_POSSIBLE" = "xtrue"; then
64349 64332 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
64350 64333 $as_echo "yes" >&6; }
64351 64334 ENABLE_GENERATE_CLASSLIST="true"
64352 64335 else
64353 64336 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
64354 64337 $as_echo "no" >&6; }
64355 64338 ENABLE_GENERATE_CLASSLIST="false"
64356 64339 fi
64357 64340 else
64358 64341 as_fn_error $? "Invalid value for --enable-generate-classlist: $enable_generate_classlist" "$LINENO" 5
64359 64342 fi
64360 64343
64361 64344
64362 64345
64363 64346
64364 64347 ###############################################################################
64365 64348 #
64366 64349 # Configure parts of the build that only affect the build performance,
64367 64350 # not the result.
64368 64351 #
64369 64352 ###############################################################################
64370 64353
64371 64354
64372 64355 # How many cores do we have on this build system?
64373 64356
64374 64357 # Check whether --with-num-cores was given.
64375 64358 if test "${with_num_cores+set}" = set; then :
64376 64359 withval=$with_num_cores;
64377 64360 fi
64378 64361
64379 64362 if test "x$with_num_cores" = x; then
64380 64363 # The number of cores were not specified, try to probe them.
64381 64364
64382 64365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
64383 64366 $as_echo_n "checking for number of cores... " >&6; }
64384 64367 NUM_CORES=1
64385 64368 FOUND_CORES=no
64386 64369
64387 64370 if test -f /proc/cpuinfo; then
64388 64371 # Looks like a Linux (or cygwin) system
64389 64372 NUM_CORES=`cat /proc/cpuinfo | grep -c processor`
64390 64373 FOUND_CORES=yes
64391 64374 elif test -x /usr/sbin/psrinfo; then
64392 64375 # Looks like a Solaris system
64393 64376 NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line`
64394 64377 FOUND_CORES=yes
64395 64378 elif test -x /usr/sbin/sysctl; then
64396 64379 # Looks like a MacOSX system
64397 64380 NUM_CORES=`/usr/sbin/sysctl -n hw.ncpu`
64398 64381 FOUND_CORES=yes
64399 64382 elif test "x$OPENJDK_BUILD_OS" = xaix ; then
64400 64383 NUM_CORES=`/usr/sbin/prtconf | grep "^Number Of Processors" | awk '{ print $4 }'`
64401 64384 FOUND_CORES=yes
64402 64385 elif test -n "$NUMBER_OF_PROCESSORS"; then
64403 64386 # On windows, look in the env
64404 64387 NUM_CORES=$NUMBER_OF_PROCESSORS
64405 64388 FOUND_CORES=yes
64406 64389 fi
64407 64390
64408 64391 if test "x$FOUND_CORES" = xyes; then
64409 64392 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
64410 64393 $as_echo "$NUM_CORES" >&6; }
64411 64394 else
64412 64395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
64413 64396 $as_echo "could not detect number of cores, defaulting to 1" >&6; }
64414 64397 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
64415 64398 $as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
64416 64399 fi
64417 64400
64418 64401 else
64419 64402 NUM_CORES=$with_num_cores
64420 64403 fi
64421 64404
64422 64405
64423 64406
64424 64407 # How much memory do we have on this build system?
64425 64408
64426 64409 # Check whether --with-memory-size was given.
64427 64410 if test "${with_memory_size+set}" = set; then :
64428 64411 withval=$with_memory_size;
64429 64412 fi
64430 64413
64431 64414 if test "x$with_memory_size" = x; then
64432 64415 # The memory size was not specified, try to probe it.
64433 64416
64434 64417 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
64435 64418 $as_echo_n "checking for memory size... " >&6; }
64436 64419 # Default to 1024 MB
64437 64420 MEMORY_SIZE=1024
64438 64421 FOUND_MEM=no
64439 64422
64440 64423 if test -f /proc/meminfo; then
64441 64424 # Looks like a Linux (or cygwin) system
64442 64425 MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'`
64443 64426 MEMORY_SIZE=`expr $MEMORY_SIZE / 1024`
64444 64427 FOUND_MEM=yes
64445 64428 elif test -x /usr/sbin/prtconf; then
64446 64429 # Looks like a Solaris or AIX system
64447 64430 MEMORY_SIZE=`/usr/sbin/prtconf 2> /dev/null | grep "^Memory [Ss]ize" | awk '{ print $3 }'`
64448 64431 FOUND_MEM=yes
64449 64432 elif test -x /usr/sbin/sysctl; then
64450 64433 # Looks like a MacOSX system
64451 64434 MEMORY_SIZE=`/usr/sbin/sysctl -n hw.memsize`
64452 64435 MEMORY_SIZE=`expr $MEMORY_SIZE / 1024 / 1024`
64453 64436 FOUND_MEM=yes
64454 64437 elif test "x$OPENJDK_BUILD_OS" = xwindows; then
64455 64438 # Windows, but without cygwin
64456 64439 MEMORY_SIZE=`wmic computersystem get totalphysicalmemory -value | grep = | cut -d "=" -f 2-`
64457 64440 MEMORY_SIZE=`expr $MEMORY_SIZE / 1024 / 1024`
64458 64441 FOUND_MEM=yes
64459 64442 fi
64460 64443
64461 64444 if test "x$FOUND_MEM" = xyes; then
64462 64445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
64463 64446 $as_echo "$MEMORY_SIZE MB" >&6; }
64464 64447 else
64465 64448 { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to $MEMORY_SIZE MB" >&5
64466 64449 $as_echo "could not detect memory size, defaulting to $MEMORY_SIZE MB" >&6; }
64467 64450 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
64468 64451 $as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
64469 64452 fi
64470 64453
64471 64454 else
64472 64455 MEMORY_SIZE=$with_memory_size
64473 64456 fi
64474 64457
64475 64458
64476 64459
64477 64460 # Provide a decent default number of parallel jobs for make depending on
64478 64461 # number of cores, amount of memory and machine architecture.
64479 64462
64480 64463 # Check whether --with-jobs was given.
64481 64464 if test "${with_jobs+set}" = set; then :
64482 64465 withval=$with_jobs;
64483 64466 fi
64484 64467
64485 64468 if test "x$with_jobs" = x; then
64486 64469 # Number of jobs was not specified, calculate.
64487 64470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
64488 64471 $as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
64489 64472 # Approximate memory in GB.
64490 64473 memory_gb=`expr $MEMORY_SIZE / 1024`
64491 64474 # Pick the lowest of memory in gb and number of cores.
64492 64475 if test "$memory_gb" -lt "$NUM_CORES"; then
64493 64476 JOBS="$memory_gb"
64494 64477 else
64495 64478 JOBS="$NUM_CORES"
64496 64479 fi
64497 64480 if test "$JOBS" -eq "0"; then
64498 64481 JOBS=1
64499 64482 fi
64500 64483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
64501 64484 $as_echo "$JOBS" >&6; }
64502 64485 else
64503 64486 JOBS=$with_jobs
64504 64487 fi
64505 64488
64506 64489
64507 64490
64508 64491 # The number of test jobs will be chosen automatically if TEST_JOBS is 0
64509 64492
64510 64493 # Check whether --with-test-jobs was given.
64511 64494 if test "${with_test_jobs+set}" = set; then :
64512 64495 withval=$with_test_jobs;
64513 64496 fi
64514 64497
64515 64498 if test "x$with_test_jobs" = x; then
64516 64499 TEST_JOBS=0
64517 64500 else
64518 64501 TEST_JOBS=$with_test_jobs
64519 64502 fi
64520 64503
64521 64504
64522 64505
64523 64506 # Setup arguments for the boot jdk (after cores and memory have been setup)
64524 64507
64525 64508 ##############################################################################
64526 64509 #
64527 64510 # Specify jvm options for anything that is run with the Boot JDK.
64528 64511 # Not all JVM:s accept the same arguments on the command line.
64529 64512 #
64530 64513
64531 64514 # Check whether --with-boot-jdk-jvmargs was given.
64532 64515 if test "${with_boot_jdk_jvmargs+set}" = set; then :
64533 64516 withval=$with_boot_jdk_jvmargs;
64534 64517 fi
64535 64518
64536 64519
64537 64520 { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
64538 64521 $as_echo_n "checking flags for boot jdk java command ... " >&6; }
64539 64522
64540 64523 # Disable special log output when a debug build is used as Boot JDK...
64541 64524
64542 64525 $ECHO "Check if jvm arg is ok: -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" >&5
64543 64526 $ECHO "Command: $JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version" >&5
64544 64527 OUTPUT=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1`
64545 64528 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64546 64529 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64547 64530 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64548 64531 boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput"
64549 64532 JVM_ARG_OK=true
64550 64533 else
64551 64534 $ECHO "Arg failed:" >&5
64552 64535 $ECHO "$OUTPUT" >&5
64553 64536 JVM_ARG_OK=false
64554 64537 fi
64555 64538
64556 64539
64557 64540 # Force en-US environment
64558 64541
64559 64542 $ECHO "Check if jvm arg is ok: -Duser.language=en -Duser.country=US" >&5
64560 64543 $ECHO "Command: $JAVA -Duser.language=en -Duser.country=US -version" >&5
64561 64544 OUTPUT=`$JAVA -Duser.language=en -Duser.country=US -version 2>&1`
64562 64545 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64563 64546 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64564 64547 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64565 64548 boot_jdk_jvmargs="$boot_jdk_jvmargs -Duser.language=en -Duser.country=US"
64566 64549 JVM_ARG_OK=true
64567 64550 else
64568 64551 $ECHO "Arg failed:" >&5
64569 64552 $ECHO "$OUTPUT" >&5
64570 64553 JVM_ARG_OK=false
64571 64554 fi
64572 64555
64573 64556
64574 64557 # Apply user provided options.
64575 64558
64576 64559 $ECHO "Check if jvm arg is ok: $with_boot_jdk_jvmargs" >&5
64577 64560 $ECHO "Command: $JAVA $with_boot_jdk_jvmargs -version" >&5
64578 64561 OUTPUT=`$JAVA $with_boot_jdk_jvmargs -version 2>&1`
64579 64562 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64580 64563 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64581 64564 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64582 64565 boot_jdk_jvmargs="$boot_jdk_jvmargs $with_boot_jdk_jvmargs"
64583 64566 JVM_ARG_OK=true
64584 64567 else
64585 64568 $ECHO "Arg failed:" >&5
64586 64569 $ECHO "$OUTPUT" >&5
64587 64570 JVM_ARG_OK=false
64588 64571 fi
64589 64572
64590 64573
64591 64574 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
64592 64575 $as_echo "$boot_jdk_jvmargs" >&6; }
64593 64576
64594 64577 # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
64595 64578 JAVA_FLAGS=$boot_jdk_jvmargs
64596 64579
64597 64580
64598 64581
64599 64582 { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
64600 64583 $as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
64601 64584
64602 64585 # Starting amount of heap memory.
64603 64586
64604 64587 $ECHO "Check if jvm arg is ok: -Xms64M" >&5
64605 64588 $ECHO "Command: $JAVA -Xms64M -version" >&5
64606 64589 OUTPUT=`$JAVA -Xms64M -version 2>&1`
64607 64590 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64608 64591 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64609 64592 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64610 64593 boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xms64M"
64611 64594 JVM_ARG_OK=true
64612 64595 else
64613 64596 $ECHO "Arg failed:" >&5
64614 64597 $ECHO "$OUTPUT" >&5
64615 64598 JVM_ARG_OK=false
64616 64599 fi
64617 64600
64618 64601 BOOTCYCLE_JVM_ARGS_BIG=-Xms64M
64619 64602
64620 64603 # Maximum amount of heap memory and stack size.
64621 64604 JVM_HEAP_LIMIT_32="1024"
64622 64605 # Running a 64 bit JVM allows for and requires a bigger heap
64623 64606 JVM_HEAP_LIMIT_64="1600"
64624 64607 STACK_SIZE_32=768
64625 64608 STACK_SIZE_64=1536
64626 64609 JVM_HEAP_LIMIT_GLOBAL=`expr $MEMORY_SIZE / 2`
64627 64610 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_32"; then
64628 64611 JVM_HEAP_LIMIT_32=$JVM_HEAP_LIMIT_GLOBAL
64629 64612 fi
64630 64613 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_64"; then
64631 64614 JVM_HEAP_LIMIT_64=$JVM_HEAP_LIMIT_GLOBAL
64632 64615 fi
64633 64616 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "512"; then
64634 64617 JVM_HEAP_LIMIT_32=512
64635 64618 JVM_HEAP_LIMIT_64=512
64636 64619 fi
64637 64620
64638 64621 if test "x$BOOT_JDK_BITS" = "x32"; then
64639 64622 STACK_SIZE=$STACK_SIZE_32
64640 64623 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_32
64641 64624 else
64642 64625 STACK_SIZE=$STACK_SIZE_64
64643 64626 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_64
64644 64627 fi
64645 64628
64646 64629 $ECHO "Check if jvm arg is ok: -Xmx${JVM_MAX_HEAP}M" >&5
64647 64630 $ECHO "Command: $JAVA -Xmx${JVM_MAX_HEAP}M -version" >&5
64648 64631 OUTPUT=`$JAVA -Xmx${JVM_MAX_HEAP}M -version 2>&1`
64649 64632 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64650 64633 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64651 64634 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64652 64635 boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xmx${JVM_MAX_HEAP}M"
64653 64636 JVM_ARG_OK=true
64654 64637 else
64655 64638 $ECHO "Arg failed:" >&5
64656 64639 $ECHO "$OUTPUT" >&5
64657 64640 JVM_ARG_OK=false
64658 64641 fi
64659 64642
64660 64643
64661 64644 $ECHO "Check if jvm arg is ok: -XX:ThreadStackSize=$STACK_SIZE" >&5
64662 64645 $ECHO "Command: $JAVA -XX:ThreadStackSize=$STACK_SIZE -version" >&5
64663 64646 OUTPUT=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1`
64664 64647 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64665 64648 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64666 64649 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64667 64650 boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -XX:ThreadStackSize=$STACK_SIZE"
64668 64651 JVM_ARG_OK=true
64669 64652 else
64670 64653 $ECHO "Arg failed:" >&5
64671 64654 $ECHO "$OUTPUT" >&5
64672 64655 JVM_ARG_OK=false
64673 64656 fi
64674 64657
64675 64658
64676 64659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
64677 64660 $as_echo "$boot_jdk_jvmargs_big" >&6; }
64678 64661
64679 64662 JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
64680 64663
64681 64664
64682 64665 if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
64683 64666 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_32
64684 64667 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_32
64685 64668 else
64686 64669 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_64
64687 64670 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_64
64688 64671 fi
64689 64672 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -Xmx${BOOTCYCLE_MAX_HEAP}M"
64690 64673 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -XX:ThreadStackSize=$BOOTCYCLE_STACK_SIZE"
64691 64674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for bootcycle boot jdk java command for big workloads" >&5
64692 64675 $as_echo_n "checking flags for bootcycle boot jdk java command for big workloads... " >&6; }
64693 64676 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOTCYCLE_JVM_ARGS_BIG" >&5
64694 64677 $as_echo "$BOOTCYCLE_JVM_ARGS_BIG" >&6; }
64695 64678
64696 64679
64697 64680 # By default, the main javac compilations use big
64698 64681 JAVA_FLAGS_JAVAC="$JAVA_FLAGS_BIG"
64699 64682
64700 64683
64701 64684 { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
64702 64685 $as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
64703 64686
64704 64687 # Use serial gc for small short lived tools if possible
64705 64688
64706 64689 $ECHO "Check if jvm arg is ok: -XX:+UseSerialGC" >&5
64707 64690 $ECHO "Command: $JAVA -XX:+UseSerialGC -version" >&5
64708 64691 OUTPUT=`$JAVA -XX:+UseSerialGC -version 2>&1`
64709 64692 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64710 64693 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64711 64694 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64712 64695 boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:+UseSerialGC"
64713 64696 JVM_ARG_OK=true
64714 64697 else
64715 64698 $ECHO "Arg failed:" >&5
64716 64699 $ECHO "$OUTPUT" >&5
64717 64700 JVM_ARG_OK=false
64718 64701 fi
64719 64702
64720 64703
64721 64704 $ECHO "Check if jvm arg is ok: -Xms32M" >&5
64722 64705 $ECHO "Command: $JAVA -Xms32M -version" >&5
64723 64706 OUTPUT=`$JAVA -Xms32M -version 2>&1`
64724 64707 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64725 64708 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64726 64709 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64727 64710 boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xms32M"
64728 64711 JVM_ARG_OK=true
64729 64712 else
64730 64713 $ECHO "Arg failed:" >&5
64731 64714 $ECHO "$OUTPUT" >&5
64732 64715 JVM_ARG_OK=false
64733 64716 fi
64734 64717
64735 64718
64736 64719 $ECHO "Check if jvm arg is ok: -Xmx512M" >&5
64737 64720 $ECHO "Command: $JAVA -Xmx512M -version" >&5
64738 64721 OUTPUT=`$JAVA -Xmx512M -version 2>&1`
64739 64722 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64740 64723 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64741 64724 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64742 64725 boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xmx512M"
64743 64726 JVM_ARG_OK=true
64744 64727 else
64745 64728 $ECHO "Arg failed:" >&5
64746 64729 $ECHO "$OUTPUT" >&5
64747 64730 JVM_ARG_OK=false
64748 64731 fi
64749 64732
64750 64733
64751 64734 $ECHO "Check if jvm arg is ok: -XX:TieredStopAtLevel=1" >&5
64752 64735 $ECHO "Command: $JAVA -XX:TieredStopAtLevel=1 -version" >&5
64753 64736 OUTPUT=`$JAVA -XX:TieredStopAtLevel=1 -version 2>&1`
64754 64737 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64755 64738 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64756 64739 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64757 64740 boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:TieredStopAtLevel=1"
64758 64741 JVM_ARG_OK=true
64759 64742 else
64760 64743 $ECHO "Arg failed:" >&5
64761 64744 $ECHO "$OUTPUT" >&5
64762 64745 JVM_ARG_OK=false
64763 64746 fi
64764 64747
64765 64748
64766 64749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
64767 64750 $as_echo "$boot_jdk_jvmargs_small" >&6; }
64768 64751
64769 64752 JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
64770 64753
64771 64754
64772 64755 JAVA_TOOL_FLAGS_SMALL=""
64773 64756 for f in $JAVA_FLAGS_SMALL; do
64774 64757 JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
64775 64758 done
64776 64759
64777 64760
64778 64761
64779 64762 # Setup smart javac (after cores and memory have been setup)
64780 64763
64781 64764
64782 64765 # Check whether --with-sjavac-server-java was given.
64783 64766 if test "${with_sjavac_server_java+set}" = set; then :
64784 64767 withval=$with_sjavac_server_java;
64785 64768 fi
64786 64769
64787 64770
64788 64771 if test "x$with_sjavac_server_java" != x; then
64789 64772 SJAVAC_SERVER_JAVA="$with_sjavac_server_java"
64790 64773 FOUND_VERSION=`$SJAVAC_SERVER_JAVA -version 2>&1 | grep " version \""`
64791 64774 if test "x$FOUND_VERSION" = x; then
64792 64775 as_fn_error $? "Could not execute server java: $SJAVAC_SERVER_JAVA" "$LINENO" 5
64793 64776 fi
64794 64777 else
64795 64778 SJAVAC_SERVER_JAVA="$JAVA"
64796 64779 fi
64797 64780
64798 64781
64799 64782 if test "$MEMORY_SIZE" -gt "3000"; then
64800 64783
64801 64784 $ECHO "Check if jvm arg is ok: -d64" >&5
64802 64785 $ECHO "Command: $SJAVAC_SERVER_JAVA -d64 -version" >&5
64803 64786 OUTPUT=`$SJAVAC_SERVER_JAVA -d64 -version 2>&1`
64804 64787 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64805 64788 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64806 64789 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64807 64790 SJAVAC_SERVER_JAVA_FLAGS="$SJAVAC_SERVER_JAVA_FLAGS -d64"
64808 64791 JVM_ARG_OK=true
64809 64792 else
64810 64793 $ECHO "Arg failed:" >&5
64811 64794 $ECHO "$OUTPUT" >&5
64812 64795 JVM_ARG_OK=false
64813 64796 fi
64814 64797
64815 64798 if test "$JVM_ARG_OK" = true; then
64816 64799 JVM_64BIT=true
64817 64800 JVM_ARG_OK=false
64818 64801 fi
64819 64802 fi
64820 64803
64821 64804 MX_VALUE=`expr $MEMORY_SIZE / 2`
64822 64805 if test "$JVM_64BIT" = true; then
64823 64806 # Set ms lower than mx since more than one instance of the server might
64824 64807 # get launched at the same time before they figure out which instance won.
64825 64808 MS_VALUE=512
64826 64809 if test "$MX_VALUE" -gt "2048"; then
64827 64810 MX_VALUE=2048
64828 64811 fi
64829 64812 else
64830 64813 MS_VALUE=256
64831 64814 if test "$MX_VALUE" -gt "1500"; then
64832 64815 MX_VALUE=1500
64833 64816 fi
64834 64817 fi
64835 64818 if test "$MX_VALUE" -lt "512"; then
64836 64819 MX_VALUE=512
64837 64820 fi
64838 64821
64839 64822 $ECHO "Check if jvm arg is ok: -Xms${MS_VALUE}M -Xmx${MX_VALUE}M" >&5
64840 64823 $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version" >&5
64841 64824 OUTPUT=`$SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version 2>&1`
64842 64825 FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
64843 64826 FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
64844 64827 if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
64845 64828 SJAVAC_SERVER_JAVA_FLAGS="$SJAVAC_SERVER_JAVA_FLAGS -Xms${MS_VALUE}M -Xmx${MX_VALUE}M"
64846 64829 JVM_ARG_OK=true
64847 64830 else
64848 64831 $ECHO "Arg failed:" >&5
64849 64832 $ECHO "$OUTPUT" >&5
64850 64833 JVM_ARG_OK=false
64851 64834 fi
64852 64835
64853 64836
64854 64837
64855 64838 # Check whether --enable-sjavac was given.
64856 64839 if test "${enable_sjavac+set}" = set; then :
64857 64840 enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
64858 64841 else
64859 64842 ENABLE_SJAVAC="no"
64860 64843 fi
64861 64844
64862 64845 if test "x$JVM_ARG_OK" = "xfalse"; then
64863 64846 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&5
64864 64847 $as_echo "$as_me: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&2;}
64865 64848 ENABLE_SJAVAC="no"
64866 64849 fi
64867 64850 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
64868 64851 $as_echo_n "checking whether to use sjavac... " >&6; }
64869 64852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
64870 64853 $as_echo "$ENABLE_SJAVAC" >&6; }
64871 64854
64872 64855
64873 64856 # Check whether --enable-javac-server was given.
64874 64857 if test "${enable_javac_server+set}" = set; then :
64875 64858 enableval=$enable_javac_server; ENABLE_JAVAC_SERVER="${enableval}"
64876 64859 else
64877 64860 ENABLE_JAVAC_SERVER="yes"
64878 64861 fi
64879 64862
64880 64863 if test "x$JVM_ARG_OK" = "xfalse"; then
64881 64864 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling javac server" >&5
64882 64865 $as_echo "$as_me: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling javac server" >&2;}
64883 64866 ENABLE_JAVAC_SERVER="no"
64884 64867 fi
64885 64868 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use javac server" >&5
64886 64869 $as_echo_n "checking whether to use javac server... " >&6; }
64887 64870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_SERVER" >&5
64888 64871 $as_echo "$ENABLE_JAVAC_SERVER" >&6; }
64889 64872
64890 64873
64891 64874 if test "x$ENABLE_JAVAC_SERVER" = "xyes" || test "x$ENABLE_SJAVAC" = "xyes"; then
64892 64875 # When using a server javac, the small client instances do not need much
64893 64876 # resources.
64894 64877 JAVA_FLAGS_JAVAC="$JAVA_FLAGS_SMALL"
64895 64878 fi
64896 64879
64897 64880
64898 64881 # Setup use of icecc if requested
64899 64882
64900 64883 # Check whether --enable-icecc was given.
64901 64884 if test "${enable_icecc+set}" = set; then :
64902 64885 enableval=$enable_icecc;
64903 64886 fi
64904 64887
64905 64888
64906 64889 if test "x${enable_icecc}" = "xyes"; then
64907 64890
64908 64891
64909 64892
64910 64893 # Publish this variable in the help.
64911 64894
64912 64895
64913 64896 if [ -z "${ICECC_CMD+x}" ]; then
64914 64897 # The variable is not set by user, try to locate tool using the code snippet
64915 64898 for ac_prog in icecc
64916 64899 do
64917 64900 # Extract the first word of "$ac_prog", so it can be a program name with args.
64918 64901 set dummy $ac_prog; ac_word=$2
64919 64902 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
64920 64903 $as_echo_n "checking for $ac_word... " >&6; }
64921 64904 if ${ac_cv_path_ICECC_CMD+:} false; then :
64922 64905 $as_echo_n "(cached) " >&6
64923 64906 else
64924 64907 case $ICECC_CMD in
64925 64908 [\\/]* | ?:[\\/]*)
64926 64909 ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
64927 64910 ;;
64928 64911 *)
64929 64912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
64930 64913 for as_dir in $PATH
64931 64914 do
64932 64915 IFS=$as_save_IFS
64933 64916 test -z "$as_dir" && as_dir=.
64934 64917 for ac_exec_ext in '' $ac_executable_extensions; do
64935 64918 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
64936 64919 ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
64937 64920 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
64938 64921 break 2
64939 64922 fi
64940 64923 done
64941 64924 done
64942 64925 IFS=$as_save_IFS
64943 64926
64944 64927 ;;
64945 64928 esac
64946 64929 fi
64947 64930 ICECC_CMD=$ac_cv_path_ICECC_CMD
64948 64931 if test -n "$ICECC_CMD"; then
64949 64932 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
64950 64933 $as_echo "$ICECC_CMD" >&6; }
64951 64934 else
64952 64935 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
64953 64936 $as_echo "no" >&6; }
64954 64937 fi
64955 64938
64956 64939
64957 64940 test -n "$ICECC_CMD" && break
64958 64941 done
64959 64942
64960 64943 else
64961 64944 # The variable is set, but is it from the command line or the environment?
64962 64945
64963 64946 # Try to remove the string !ICECC_CMD! from our list.
64964 64947 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_CMD!/}
64965 64948 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
64966 64949 # If it failed, the variable was not from the command line. Ignore it,
64967 64950 # but warn the user (except for BASH, which is always set by the calling BASH).
64968 64951 if test "xICECC_CMD" != xBASH; then
64969 64952 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_CMD from the environment. Use command line variables instead." >&5
64970 64953 $as_echo "$as_me: WARNING: Ignoring value of ICECC_CMD from the environment. Use command line variables instead." >&2;}
64971 64954 fi
64972 64955 # Try to locate tool using the code snippet
64973 64956 for ac_prog in icecc
64974 64957 do
64975 64958 # Extract the first word of "$ac_prog", so it can be a program name with args.
64976 64959 set dummy $ac_prog; ac_word=$2
64977 64960 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
64978 64961 $as_echo_n "checking for $ac_word... " >&6; }
64979 64962 if ${ac_cv_path_ICECC_CMD+:} false; then :
64980 64963 $as_echo_n "(cached) " >&6
64981 64964 else
64982 64965 case $ICECC_CMD in
64983 64966 [\\/]* | ?:[\\/]*)
64984 64967 ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
64985 64968 ;;
64986 64969 *)
64987 64970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
64988 64971 for as_dir in $PATH
64989 64972 do
64990 64973 IFS=$as_save_IFS
64991 64974 test -z "$as_dir" && as_dir=.
64992 64975 for ac_exec_ext in '' $ac_executable_extensions; do
64993 64976 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
64994 64977 ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
64995 64978 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
64996 64979 break 2
64997 64980 fi
64998 64981 done
64999 64982 done
65000 64983 IFS=$as_save_IFS
65001 64984
65002 64985 ;;
65003 64986 esac
65004 64987 fi
65005 64988 ICECC_CMD=$ac_cv_path_ICECC_CMD
65006 64989 if test -n "$ICECC_CMD"; then
65007 64990 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
65008 64991 $as_echo "$ICECC_CMD" >&6; }
65009 64992 else
65010 64993 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65011 64994 $as_echo "no" >&6; }
65012 64995 fi
65013 64996
65014 64997
65015 64998 test -n "$ICECC_CMD" && break
65016 64999 done
65017 65000
65018 65001 else
65019 65002 # If it succeeded, then it was overridden by the user. We will use it
65020 65003 # for the tool.
65021 65004
65022 65005 # First remove it from the list of overridden variables, so we can test
65023 65006 # for unknown variables in the end.
65024 65007 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
65025 65008
65026 65009 # Check if we try to supply an empty value
65027 65010 if test "x$ICECC_CMD" = x; then
65028 65011 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_CMD= (no value)" >&5
65029 65012 $as_echo "$as_me: Setting user supplied tool ICECC_CMD= (no value)" >&6;}
65030 65013 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CMD" >&5
65031 65014 $as_echo_n "checking for ICECC_CMD... " >&6; }
65032 65015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
65033 65016 $as_echo "disabled" >&6; }
65034 65017 else
65035 65018 # Check if the provided tool contains a complete path.
65036 65019 tool_specified="$ICECC_CMD"
65037 65020 tool_basename="${tool_specified##*/}"
65038 65021 if test "x$tool_basename" = "x$tool_specified"; then
65039 65022 # A command without a complete path is provided, search $PATH.
65040 65023 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_CMD=$tool_basename" >&5
65041 65024 $as_echo "$as_me: Will search for user supplied tool ICECC_CMD=$tool_basename" >&6;}
65042 65025 # Extract the first word of "$tool_basename", so it can be a program name with args.
65043 65026 set dummy $tool_basename; ac_word=$2
65044 65027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65045 65028 $as_echo_n "checking for $ac_word... " >&6; }
65046 65029 if ${ac_cv_path_ICECC_CMD+:} false; then :
65047 65030 $as_echo_n "(cached) " >&6
65048 65031 else
65049 65032 case $ICECC_CMD in
65050 65033 [\\/]* | ?:[\\/]*)
65051 65034 ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
65052 65035 ;;
65053 65036 *)
65054 65037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65055 65038 for as_dir in $PATH
65056 65039 do
65057 65040 IFS=$as_save_IFS
65058 65041 test -z "$as_dir" && as_dir=.
65059 65042 for ac_exec_ext in '' $ac_executable_extensions; do
65060 65043 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65061 65044 ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
65062 65045 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65063 65046 break 2
65064 65047 fi
65065 65048 done
65066 65049 done
65067 65050 IFS=$as_save_IFS
65068 65051
65069 65052 ;;
65070 65053 esac
65071 65054 fi
65072 65055 ICECC_CMD=$ac_cv_path_ICECC_CMD
65073 65056 if test -n "$ICECC_CMD"; then
65074 65057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
65075 65058 $as_echo "$ICECC_CMD" >&6; }
65076 65059 else
65077 65060 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65078 65061 $as_echo "no" >&6; }
65079 65062 fi
65080 65063
65081 65064
65082 65065 if test "x$ICECC_CMD" = x; then
65083 65066 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
65084 65067 fi
65085 65068 else
65086 65069 # Otherwise we believe it is a complete path. Use it as it is.
65087 65070 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_CMD=$tool_specified" >&5
65088 65071 $as_echo "$as_me: Will use user supplied tool ICECC_CMD=$tool_specified" >&6;}
65089 65072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CMD" >&5
65090 65073 $as_echo_n "checking for ICECC_CMD... " >&6; }
65091 65074 if test ! -x "$tool_specified"; then
65092 65075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
65093 65076 $as_echo "not found" >&6; }
65094 65077 as_fn_error $? "User supplied tool ICECC_CMD=$tool_specified does not exist or is not executable" "$LINENO" 5
65095 65078 fi
65096 65079 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
65097 65080 $as_echo "$tool_specified" >&6; }
65098 65081 fi
65099 65082 fi
65100 65083 fi
65101 65084
65102 65085 fi
65103 65086
65104 65087
65105 65088
65106 65089 if test "x$ICECC_CMD" = x; then
65107 65090 as_fn_error $? "Could not find required tool for ICECC_CMD" "$LINENO" 5
65108 65091 fi
65109 65092
65110 65093
65111 65094 old_path="$PATH"
65112 65095
65113 65096 # Look for icecc-create-env in some known places
65114 65097 PATH="$PATH:/usr/lib/icecc:/usr/lib64/icecc"
65115 65098
65116 65099
65117 65100
65118 65101 # Publish this variable in the help.
65119 65102
65120 65103
65121 65104 if [ -z "${ICECC_CREATE_ENV+x}" ]; then
65122 65105 # The variable is not set by user, try to locate tool using the code snippet
65123 65106 for ac_prog in icecc-create-env
65124 65107 do
65125 65108 # Extract the first word of "$ac_prog", so it can be a program name with args.
65126 65109 set dummy $ac_prog; ac_word=$2
65127 65110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65128 65111 $as_echo_n "checking for $ac_word... " >&6; }
65129 65112 if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
65130 65113 $as_echo_n "(cached) " >&6
65131 65114 else
65132 65115 case $ICECC_CREATE_ENV in
65133 65116 [\\/]* | ?:[\\/]*)
65134 65117 ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
65135 65118 ;;
65136 65119 *)
65137 65120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65138 65121 for as_dir in $PATH
65139 65122 do
65140 65123 IFS=$as_save_IFS
65141 65124 test -z "$as_dir" && as_dir=.
65142 65125 for ac_exec_ext in '' $ac_executable_extensions; do
65143 65126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65144 65127 ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
65145 65128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65146 65129 break 2
65147 65130 fi
65148 65131 done
65149 65132 done
65150 65133 IFS=$as_save_IFS
65151 65134
65152 65135 ;;
65153 65136 esac
65154 65137 fi
65155 65138 ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
65156 65139 if test -n "$ICECC_CREATE_ENV"; then
65157 65140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
65158 65141 $as_echo "$ICECC_CREATE_ENV" >&6; }
65159 65142 else
65160 65143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65161 65144 $as_echo "no" >&6; }
65162 65145 fi
65163 65146
65164 65147
65165 65148 test -n "$ICECC_CREATE_ENV" && break
65166 65149 done
65167 65150
65168 65151 else
65169 65152 # The variable is set, but is it from the command line or the environment?
65170 65153
65171 65154 # Try to remove the string !ICECC_CREATE_ENV! from our list.
65172 65155 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_CREATE_ENV!/}
65173 65156 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
65174 65157 # If it failed, the variable was not from the command line. Ignore it,
65175 65158 # but warn the user (except for BASH, which is always set by the calling BASH).
65176 65159 if test "xICECC_CREATE_ENV" != xBASH; then
65177 65160 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_CREATE_ENV from the environment. Use command line variables instead." >&5
65178 65161 $as_echo "$as_me: WARNING: Ignoring value of ICECC_CREATE_ENV from the environment. Use command line variables instead." >&2;}
65179 65162 fi
65180 65163 # Try to locate tool using the code snippet
65181 65164 for ac_prog in icecc-create-env
65182 65165 do
65183 65166 # Extract the first word of "$ac_prog", so it can be a program name with args.
65184 65167 set dummy $ac_prog; ac_word=$2
65185 65168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65186 65169 $as_echo_n "checking for $ac_word... " >&6; }
65187 65170 if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
65188 65171 $as_echo_n "(cached) " >&6
65189 65172 else
65190 65173 case $ICECC_CREATE_ENV in
65191 65174 [\\/]* | ?:[\\/]*)
65192 65175 ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
65193 65176 ;;
65194 65177 *)
65195 65178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65196 65179 for as_dir in $PATH
65197 65180 do
65198 65181 IFS=$as_save_IFS
65199 65182 test -z "$as_dir" && as_dir=.
65200 65183 for ac_exec_ext in '' $ac_executable_extensions; do
65201 65184 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65202 65185 ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
65203 65186 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65204 65187 break 2
65205 65188 fi
65206 65189 done
65207 65190 done
65208 65191 IFS=$as_save_IFS
65209 65192
65210 65193 ;;
65211 65194 esac
65212 65195 fi
65213 65196 ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
65214 65197 if test -n "$ICECC_CREATE_ENV"; then
65215 65198 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
65216 65199 $as_echo "$ICECC_CREATE_ENV" >&6; }
65217 65200 else
65218 65201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65219 65202 $as_echo "no" >&6; }
65220 65203 fi
65221 65204
65222 65205
65223 65206 test -n "$ICECC_CREATE_ENV" && break
65224 65207 done
65225 65208
65226 65209 else
65227 65210 # If it succeeded, then it was overridden by the user. We will use it
65228 65211 # for the tool.
65229 65212
65230 65213 # First remove it from the list of overridden variables, so we can test
65231 65214 # for unknown variables in the end.
65232 65215 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
65233 65216
65234 65217 # Check if we try to supply an empty value
65235 65218 if test "x$ICECC_CREATE_ENV" = x; then
65236 65219 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_CREATE_ENV= (no value)" >&5
65237 65220 $as_echo "$as_me: Setting user supplied tool ICECC_CREATE_ENV= (no value)" >&6;}
65238 65221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CREATE_ENV" >&5
65239 65222 $as_echo_n "checking for ICECC_CREATE_ENV... " >&6; }
65240 65223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
65241 65224 $as_echo "disabled" >&6; }
65242 65225 else
65243 65226 # Check if the provided tool contains a complete path.
65244 65227 tool_specified="$ICECC_CREATE_ENV"
65245 65228 tool_basename="${tool_specified##*/}"
65246 65229 if test "x$tool_basename" = "x$tool_specified"; then
65247 65230 # A command without a complete path is provided, search $PATH.
65248 65231 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_CREATE_ENV=$tool_basename" >&5
65249 65232 $as_echo "$as_me: Will search for user supplied tool ICECC_CREATE_ENV=$tool_basename" >&6;}
65250 65233 # Extract the first word of "$tool_basename", so it can be a program name with args.
65251 65234 set dummy $tool_basename; ac_word=$2
65252 65235 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65253 65236 $as_echo_n "checking for $ac_word... " >&6; }
65254 65237 if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
65255 65238 $as_echo_n "(cached) " >&6
65256 65239 else
65257 65240 case $ICECC_CREATE_ENV in
65258 65241 [\\/]* | ?:[\\/]*)
65259 65242 ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
65260 65243 ;;
65261 65244 *)
65262 65245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65263 65246 for as_dir in $PATH
65264 65247 do
65265 65248 IFS=$as_save_IFS
65266 65249 test -z "$as_dir" && as_dir=.
65267 65250 for ac_exec_ext in '' $ac_executable_extensions; do
65268 65251 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65269 65252 ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
65270 65253 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65271 65254 break 2
65272 65255 fi
65273 65256 done
65274 65257 done
65275 65258 IFS=$as_save_IFS
65276 65259
65277 65260 ;;
65278 65261 esac
65279 65262 fi
65280 65263 ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
65281 65264 if test -n "$ICECC_CREATE_ENV"; then
65282 65265 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
65283 65266 $as_echo "$ICECC_CREATE_ENV" >&6; }
65284 65267 else
65285 65268 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65286 65269 $as_echo "no" >&6; }
65287 65270 fi
65288 65271
65289 65272
65290 65273 if test "x$ICECC_CREATE_ENV" = x; then
65291 65274 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
65292 65275 fi
65293 65276 else
65294 65277 # Otherwise we believe it is a complete path. Use it as it is.
65295 65278 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_CREATE_ENV=$tool_specified" >&5
65296 65279 $as_echo "$as_me: Will use user supplied tool ICECC_CREATE_ENV=$tool_specified" >&6;}
65297 65280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CREATE_ENV" >&5
65298 65281 $as_echo_n "checking for ICECC_CREATE_ENV... " >&6; }
65299 65282 if test ! -x "$tool_specified"; then
65300 65283 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
65301 65284 $as_echo "not found" >&6; }
65302 65285 as_fn_error $? "User supplied tool ICECC_CREATE_ENV=$tool_specified does not exist or is not executable" "$LINENO" 5
65303 65286 fi
65304 65287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
65305 65288 $as_echo "$tool_specified" >&6; }
65306 65289 fi
65307 65290 fi
65308 65291 fi
65309 65292
65310 65293 fi
65311 65294
65312 65295
65313 65296
65314 65297 if test "x$ICECC_CREATE_ENV" = x; then
65315 65298 as_fn_error $? "Could not find required tool for ICECC_CREATE_ENV" "$LINENO" 5
65316 65299 fi
65317 65300
65318 65301
65319 65302 # Use icecc-create-env to create a minimal compilation environment that can
65320 65303 # be sent to the other hosts in the icecream cluster.
65321 65304 icecc_create_env_log="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/icecc_create_env.log"
65322 65305 ${MKDIR} -p ${CONFIGURESUPPORT_OUTPUTDIR}/icecc
65323 65306 # Older versions of icecc does not have the --gcc parameter
65324 65307 if ${ICECC_CREATE_ENV} | $GREP -q -e --gcc; then
65325 65308 icecc_gcc_arg="--gcc"
65326 65309 fi
65327 65310 if test "x${TOOLCHAIN_TYPE}" = "xgcc"; then
65328 65311
65329 65312 ( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
65330 65313 && ${ICECC_CREATE_ENV} ${icecc_gcc_arg} ${CC} ${CXX} > \
65331 65314 ${icecc_create_env_log} 2>&1 )
65332 65315 if test "$?" != "0"; then
65333 65316 { $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
65334 65317 $as_echo "$as_me: icecc-create-env output:" >&6;}
65335 65318 cat \
65336 65319 ${icecc_create_env_log}
65337 65320 as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
65338 65321 fi
65339 65322
65340 65323 elif test "x$TOOLCHAIN_TYPE" = "xclang"; then
65341 65324 # For clang, the icecc compilerwrapper is needed. It usually resides next
65342 65325 # to icecc-create-env.
65343 65326
65344 65327
65345 65328
65346 65329 # Publish this variable in the help.
65347 65330
65348 65331
65349 65332 if [ -z "${ICECC_WRAPPER+x}" ]; then
65350 65333 # The variable is not set by user, try to locate tool using the code snippet
65351 65334 for ac_prog in compilerwrapper
65352 65335 do
65353 65336 # Extract the first word of "$ac_prog", so it can be a program name with args.
65354 65337 set dummy $ac_prog; ac_word=$2
65355 65338 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65356 65339 $as_echo_n "checking for $ac_word... " >&6; }
65357 65340 if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
65358 65341 $as_echo_n "(cached) " >&6
65359 65342 else
65360 65343 case $ICECC_WRAPPER in
65361 65344 [\\/]* | ?:[\\/]*)
65362 65345 ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
65363 65346 ;;
65364 65347 *)
65365 65348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65366 65349 for as_dir in $PATH
65367 65350 do
65368 65351 IFS=$as_save_IFS
65369 65352 test -z "$as_dir" && as_dir=.
65370 65353 for ac_exec_ext in '' $ac_executable_extensions; do
65371 65354 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65372 65355 ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
65373 65356 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65374 65357 break 2
65375 65358 fi
65376 65359 done
65377 65360 done
65378 65361 IFS=$as_save_IFS
65379 65362
65380 65363 ;;
65381 65364 esac
65382 65365 fi
65383 65366 ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
65384 65367 if test -n "$ICECC_WRAPPER"; then
65385 65368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
65386 65369 $as_echo "$ICECC_WRAPPER" >&6; }
65387 65370 else
65388 65371 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65389 65372 $as_echo "no" >&6; }
65390 65373 fi
65391 65374
65392 65375
65393 65376 test -n "$ICECC_WRAPPER" && break
65394 65377 done
65395 65378
65396 65379 else
65397 65380 # The variable is set, but is it from the command line or the environment?
65398 65381
65399 65382 # Try to remove the string !ICECC_WRAPPER! from our list.
65400 65383 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_WRAPPER!/}
65401 65384 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
65402 65385 # If it failed, the variable was not from the command line. Ignore it,
65403 65386 # but warn the user (except for BASH, which is always set by the calling BASH).
65404 65387 if test "xICECC_WRAPPER" != xBASH; then
65405 65388 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_WRAPPER from the environment. Use command line variables instead." >&5
65406 65389 $as_echo "$as_me: WARNING: Ignoring value of ICECC_WRAPPER from the environment. Use command line variables instead." >&2;}
65407 65390 fi
65408 65391 # Try to locate tool using the code snippet
65409 65392 for ac_prog in compilerwrapper
65410 65393 do
65411 65394 # Extract the first word of "$ac_prog", so it can be a program name with args.
65412 65395 set dummy $ac_prog; ac_word=$2
65413 65396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65414 65397 $as_echo_n "checking for $ac_word... " >&6; }
65415 65398 if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
65416 65399 $as_echo_n "(cached) " >&6
65417 65400 else
65418 65401 case $ICECC_WRAPPER in
65419 65402 [\\/]* | ?:[\\/]*)
65420 65403 ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
65421 65404 ;;
65422 65405 *)
65423 65406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65424 65407 for as_dir in $PATH
65425 65408 do
65426 65409 IFS=$as_save_IFS
65427 65410 test -z "$as_dir" && as_dir=.
65428 65411 for ac_exec_ext in '' $ac_executable_extensions; do
65429 65412 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65430 65413 ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
65431 65414 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65432 65415 break 2
65433 65416 fi
65434 65417 done
65435 65418 done
65436 65419 IFS=$as_save_IFS
65437 65420
65438 65421 ;;
65439 65422 esac
65440 65423 fi
65441 65424 ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
65442 65425 if test -n "$ICECC_WRAPPER"; then
65443 65426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
65444 65427 $as_echo "$ICECC_WRAPPER" >&6; }
65445 65428 else
65446 65429 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65447 65430 $as_echo "no" >&6; }
65448 65431 fi
65449 65432
65450 65433
65451 65434 test -n "$ICECC_WRAPPER" && break
65452 65435 done
65453 65436
65454 65437 else
65455 65438 # If it succeeded, then it was overridden by the user. We will use it
65456 65439 # for the tool.
65457 65440
65458 65441 # First remove it from the list of overridden variables, so we can test
65459 65442 # for unknown variables in the end.
65460 65443 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
65461 65444
65462 65445 # Check if we try to supply an empty value
65463 65446 if test "x$ICECC_WRAPPER" = x; then
65464 65447 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_WRAPPER= (no value)" >&5
65465 65448 $as_echo "$as_me: Setting user supplied tool ICECC_WRAPPER= (no value)" >&6;}
65466 65449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_WRAPPER" >&5
65467 65450 $as_echo_n "checking for ICECC_WRAPPER... " >&6; }
65468 65451 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
65469 65452 $as_echo "disabled" >&6; }
65470 65453 else
65471 65454 # Check if the provided tool contains a complete path.
65472 65455 tool_specified="$ICECC_WRAPPER"
65473 65456 tool_basename="${tool_specified##*/}"
65474 65457 if test "x$tool_basename" = "x$tool_specified"; then
65475 65458 # A command without a complete path is provided, search $PATH.
65476 65459 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_WRAPPER=$tool_basename" >&5
65477 65460 $as_echo "$as_me: Will search for user supplied tool ICECC_WRAPPER=$tool_basename" >&6;}
65478 65461 # Extract the first word of "$tool_basename", so it can be a program name with args.
65479 65462 set dummy $tool_basename; ac_word=$2
65480 65463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65481 65464 $as_echo_n "checking for $ac_word... " >&6; }
65482 65465 if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
65483 65466 $as_echo_n "(cached) " >&6
65484 65467 else
65485 65468 case $ICECC_WRAPPER in
65486 65469 [\\/]* | ?:[\\/]*)
65487 65470 ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
65488 65471 ;;
65489 65472 *)
65490 65473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65491 65474 for as_dir in $PATH
65492 65475 do
65493 65476 IFS=$as_save_IFS
65494 65477 test -z "$as_dir" && as_dir=.
65495 65478 for ac_exec_ext in '' $ac_executable_extensions; do
65496 65479 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65497 65480 ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
65498 65481 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65499 65482 break 2
65500 65483 fi
65501 65484 done
65502 65485 done
65503 65486 IFS=$as_save_IFS
65504 65487
65505 65488 ;;
65506 65489 esac
65507 65490 fi
65508 65491 ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
65509 65492 if test -n "$ICECC_WRAPPER"; then
65510 65493 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
65511 65494 $as_echo "$ICECC_WRAPPER" >&6; }
65512 65495 else
65513 65496 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65514 65497 $as_echo "no" >&6; }
65515 65498 fi
65516 65499
65517 65500
65518 65501 if test "x$ICECC_WRAPPER" = x; then
65519 65502 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
65520 65503 fi
65521 65504 else
65522 65505 # Otherwise we believe it is a complete path. Use it as it is.
65523 65506 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_WRAPPER=$tool_specified" >&5
65524 65507 $as_echo "$as_me: Will use user supplied tool ICECC_WRAPPER=$tool_specified" >&6;}
65525 65508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_WRAPPER" >&5
65526 65509 $as_echo_n "checking for ICECC_WRAPPER... " >&6; }
65527 65510 if test ! -x "$tool_specified"; then
65528 65511 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
65529 65512 $as_echo "not found" >&6; }
65530 65513 as_fn_error $? "User supplied tool ICECC_WRAPPER=$tool_specified does not exist or is not executable" "$LINENO" 5
65531 65514 fi
65532 65515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
65533 65516 $as_echo "$tool_specified" >&6; }
65534 65517 fi
65535 65518 fi
65536 65519 fi
65537 65520
65538 65521 fi
65539 65522
65540 65523
65541 65524
65542 65525 if test "x$ICECC_WRAPPER" = x; then
65543 65526 as_fn_error $? "Could not find required tool for ICECC_WRAPPER" "$LINENO" 5
65544 65527 fi
65545 65528
65546 65529
65547 65530
65548 65531 ( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
65549 65532 && ${ICECC_CREATE_ENV} --clang ${CC} ${ICECC_WRAPPER} > ${icecc_create_env_log} 2>&1 )
65550 65533 if test "$?" != "0"; then
65551 65534 { $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
65552 65535 $as_echo "$as_me: icecc-create-env output:" >&6;}
65553 65536 cat ${icecc_create_env_log}
65554 65537 as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
65555 65538 fi
65556 65539
65557 65540 else
65558 65541 as_fn_error $? "Can only create icecc compiler packages for toolchain types gcc and clang" "$LINENO" 5
65559 65542 fi
65560 65543 PATH="$old_path"
65561 65544 # The bundle with the compiler gets a name based on checksums. Parse log file
65562 65545 # to find it.
65563 65546 ICECC_ENV_BUNDLE_BASENAME="`${SED} -n '/^creating/s/creating //p' ${icecc_create_env_log}`"
65564 65547 ICECC_ENV_BUNDLE="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/${ICECC_ENV_BUNDLE_BASENAME}"
65565 65548 if test ! -f ${ICECC_ENV_BUNDLE}; then
65566 65549 as_fn_error $? "icecc-create-env did not produce an environment ${ICECC_ENV_BUNDLE}" "$LINENO" 5
65567 65550 fi
65568 65551 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for icecc build environment for target compiler" >&5
65569 65552 $as_echo_n "checking for icecc build environment for target compiler... " >&6; }
65570 65553 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ICECC_ENV_BUNDLE}" >&5
65571 65554 $as_echo "${ICECC_ENV_BUNDLE}" >&6; }
65572 65555 ICECC="ICECC_VERSION=${ICECC_ENV_BUNDLE} ICECC_CC=${CC} ICECC_CXX=${CXX} ${ICECC_CMD}"
65573 65556
65574 65557 if test "x${COMPILE_TYPE}" = "xcross"; then
65575 65558 # If cross compiling, create a separate env package for the build compiler
65576 65559 # Assume "gcc" or "cc" is gcc and "clang" is clang. Otherwise bail.
65577 65560 icecc_create_env_log_build="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/icecc_create_env_build.log"
65578 65561 if test "x${BUILD_CC##*/}" = "xgcc" || test "x${BUILD_CC##*/}" = "xcc"; then
65579 65562
65580 65563 ( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
65581 65564 && ${ICECC_CREATE_ENV} ${icecc_gcc_arg} ${BUILD_CC} ${BUILD_CXX} > \
65582 65565 ${icecc_create_env_log_build} 2>&1 )
65583 65566 if test "$?" != "0"; then
65584 65567 { $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
65585 65568 $as_echo "$as_me: icecc-create-env output:" >&6;}
65586 65569 cat \
65587 65570 ${icecc_create_env_log_build}
65588 65571 as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
65589 65572 fi
65590 65573
65591 65574 elif test "x${BUILD_CC##*/}" = "xclang"; then
65592 65575
65593 65576 ( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
65594 65577 && ${ICECC_CREATE_ENV} --clang ${BUILD_CC} ${ICECC_WRAPPER} > ${icecc_create_env_log_build} 2>&1 )
65595 65578 if test "$?" != "0"; then
65596 65579 { $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
65597 65580 $as_echo "$as_me: icecc-create-env output:" >&6;}
65598 65581 cat ${icecc_create_env_log_build}
65599 65582 as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
65600 65583 fi
65601 65584
65602 65585 else
65603 65586 as_fn_error $? "Cannot create icecc compiler package for ${BUILD_CC}" "$LINENO" 5
65604 65587 fi
65605 65588 ICECC_ENV_BUNDLE_BASENAME="`${SED} -n '/^creating/s/creating //p' ${icecc_create_env_log_build}`"
65606 65589 ICECC_ENV_BUNDLE="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/${ICECC_ENV_BUNDLE_BASENAME}"
65607 65590 if test ! -f ${ICECC_ENV_BUNDLE}; then
65608 65591 as_fn_error $? "icecc-create-env did not produce an environment ${ICECC_ENV_BUNDLE}" "$LINENO" 5
65609 65592 fi
65610 65593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for icecc build environment for build compiler" >&5
65611 65594 $as_echo_n "checking for icecc build environment for build compiler... " >&6; }
65612 65595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ICECC_ENV_BUNDLE}" >&5
65613 65596 $as_echo "${ICECC_ENV_BUNDLE}" >&6; }
65614 65597 BUILD_ICECC="ICECC_VERSION=${ICECC_ENV_BUNDLE} ICECC_CC=${BUILD_CC} \
65615 65598 ICECC_CXX=${BUILD_CXX} ${ICECC_CMD}"
65616 65599 else
65617 65600 BUILD_ICECC="${ICECC}"
65618 65601 fi
65619 65602
65620 65603
65621 65604 fi
65622 65605
65623 65606
65624 65607 # Can the C/C++ compiler use precompiled headers?
65625 65608
65626 65609
65627 65610 ###############################################################################
65628 65611 #
65629 65612 # Can the C/C++ compiler use precompiled headers?
65630 65613 #
65631 65614 # Check whether --enable-precompiled-headers was given.
65632 65615 if test "${enable_precompiled_headers+set}" = set; then :
65633 65616 enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled_headers}
65634 65617 else
65635 65618 ENABLE_PRECOMPH=yes
65636 65619 fi
65637 65620
65638 65621
65639 65622 USE_PRECOMPILED_HEADER=1
65640 65623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking If precompiled header is enabled" >&5
65641 65624 $as_echo_n "checking If precompiled header is enabled... " >&6; }
65642 65625 if test "x$ENABLE_PRECOMPH" = xno; then
65643 65626 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
65644 65627 $as_echo "no, forced" >&6; }
65645 65628 USE_PRECOMPILED_HEADER=0
65646 65629 elif test "x$ICECC" != "x"; then
65647 65630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work effectively with icecc" >&5
65648 65631 $as_echo "no, does not work effectively with icecc" >&6; }
65649 65632 USE_PRECOMPILED_HEADER=0
65650 65633 elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
65651 65634 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work with Solaris Studio" >&5
65652 65635 $as_echo "no, does not work with Solaris Studio" >&6; }
65653 65636 USE_PRECOMPILED_HEADER=0
65654 65637 elif test "x$TOOLCHAIN_TYPE" = xxlc; then
65655 65638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work with xlc" >&5
65656 65639 $as_echo "no, does not work with xlc" >&6; }
65657 65640 USE_PRECOMPILED_HEADER=0
65658 65641 else
65659 65642 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
65660 65643 $as_echo "yes" >&6; }
65661 65644 fi
65662 65645
65663 65646 if test "x$ENABLE_PRECOMPH" = xyes; then
65664 65647 # Check that the compiler actually supports precomp headers.
65665 65648 if test "x$TOOLCHAIN_TYPE" = xgcc; then
65666 65649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
65667 65650 $as_echo_n "checking that precompiled headers work... " >&6; }
65668 65651 echo "int alfa();" > conftest.h
65669 65652 $CXX -x c++-header conftest.h -o conftest.hpp.gch 2>&5 >&5
65670 65653 if test ! -f conftest.hpp.gch; then
65671 65654 USE_PRECOMPILED_HEADER=0
65672 65655 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65673 65656 $as_echo "no" >&6; }
65674 65657 else
65675 65658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
65676 65659 $as_echo "yes" >&6; }
65677 65660 fi
65678 65661 $RM conftest.h conftest.hpp.gch
65679 65662 fi
65680 65663 fi
65681 65664
65682 65665
65683 65666
65684 65667
65685 65668 # Setup use of ccache, if available
65686 65669
65687 65670 # Check whether --enable-ccache was given.
65688 65671 if test "${enable_ccache+set}" = set; then :
65689 65672 enableval=$enable_ccache;
65690 65673 fi
65691 65674
65692 65675
65693 65676 CCACHE=
65694 65677 CCACHE_STATUS=
65695 65678 { $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
65696 65679 $as_echo_n "checking is ccache enabled... " >&6; }
65697 65680 if test "x$enable_ccache" = xyes; then
65698 65681 if test "x$TOOLCHAIN_TYPE" = "xgcc" -o "x$TOOLCHAIN_TYPE" = "xclang"; then
65699 65682 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
65700 65683 $as_echo "yes" >&6; }
65701 65684 OLD_PATH="$PATH"
65702 65685 if test "x$TOOLCHAIN_PATH" != x; then
65703 65686 PATH=$TOOLCHAIN_PATH:$PATH
65704 65687 fi
65705 65688
65706 65689
65707 65690
65708 65691 # Publish this variable in the help.
65709 65692
65710 65693
65711 65694 if [ -z "${CCACHE+x}" ]; then
65712 65695 # The variable is not set by user, try to locate tool using the code snippet
65713 65696 for ac_prog in ccache
65714 65697 do
65715 65698 # Extract the first word of "$ac_prog", so it can be a program name with args.
65716 65699 set dummy $ac_prog; ac_word=$2
65717 65700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65718 65701 $as_echo_n "checking for $ac_word... " >&6; }
65719 65702 if ${ac_cv_path_CCACHE+:} false; then :
65720 65703 $as_echo_n "(cached) " >&6
65721 65704 else
65722 65705 case $CCACHE in
65723 65706 [\\/]* | ?:[\\/]*)
65724 65707 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
65725 65708 ;;
65726 65709 *)
65727 65710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65728 65711 for as_dir in $PATH
65729 65712 do
65730 65713 IFS=$as_save_IFS
65731 65714 test -z "$as_dir" && as_dir=.
65732 65715 for ac_exec_ext in '' $ac_executable_extensions; do
65733 65716 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65734 65717 ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
65735 65718 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65736 65719 break 2
65737 65720 fi
65738 65721 done
65739 65722 done
65740 65723 IFS=$as_save_IFS
65741 65724
65742 65725 ;;
65743 65726 esac
65744 65727 fi
65745 65728 CCACHE=$ac_cv_path_CCACHE
65746 65729 if test -n "$CCACHE"; then
65747 65730 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
65748 65731 $as_echo "$CCACHE" >&6; }
65749 65732 else
65750 65733 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65751 65734 $as_echo "no" >&6; }
65752 65735 fi
65753 65736
65754 65737
65755 65738 test -n "$CCACHE" && break
65756 65739 done
65757 65740
65758 65741 else
65759 65742 # The variable is set, but is it from the command line or the environment?
65760 65743
65761 65744 # Try to remove the string !CCACHE! from our list.
65762 65745 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CCACHE!/}
65763 65746 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
65764 65747 # If it failed, the variable was not from the command line. Ignore it,
65765 65748 # but warn the user (except for BASH, which is always set by the calling BASH).
65766 65749 if test "xCCACHE" != xBASH; then
65767 65750 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
65768 65751 $as_echo "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
65769 65752 fi
65770 65753 # Try to locate tool using the code snippet
65771 65754 for ac_prog in ccache
65772 65755 do
65773 65756 # Extract the first word of "$ac_prog", so it can be a program name with args.
65774 65757 set dummy $ac_prog; ac_word=$2
65775 65758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65776 65759 $as_echo_n "checking for $ac_word... " >&6; }
65777 65760 if ${ac_cv_path_CCACHE+:} false; then :
65778 65761 $as_echo_n "(cached) " >&6
65779 65762 else
65780 65763 case $CCACHE in
65781 65764 [\\/]* | ?:[\\/]*)
65782 65765 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
65783 65766 ;;
65784 65767 *)
65785 65768 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65786 65769 for as_dir in $PATH
65787 65770 do
65788 65771 IFS=$as_save_IFS
65789 65772 test -z "$as_dir" && as_dir=.
65790 65773 for ac_exec_ext in '' $ac_executable_extensions; do
65791 65774 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65792 65775 ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
65793 65776 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65794 65777 break 2
65795 65778 fi
65796 65779 done
65797 65780 done
65798 65781 IFS=$as_save_IFS
65799 65782
65800 65783 ;;
65801 65784 esac
65802 65785 fi
65803 65786 CCACHE=$ac_cv_path_CCACHE
65804 65787 if test -n "$CCACHE"; then
65805 65788 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
65806 65789 $as_echo "$CCACHE" >&6; }
65807 65790 else
65808 65791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65809 65792 $as_echo "no" >&6; }
65810 65793 fi
65811 65794
65812 65795
65813 65796 test -n "$CCACHE" && break
65814 65797 done
65815 65798
65816 65799 else
65817 65800 # If it succeeded, then it was overridden by the user. We will use it
65818 65801 # for the tool.
65819 65802
65820 65803 # First remove it from the list of overridden variables, so we can test
65821 65804 # for unknown variables in the end.
65822 65805 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
65823 65806
65824 65807 # Check if we try to supply an empty value
65825 65808 if test "x$CCACHE" = x; then
65826 65809 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CCACHE= (no value)" >&5
65827 65810 $as_echo "$as_me: Setting user supplied tool CCACHE= (no value)" >&6;}
65828 65811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
65829 65812 $as_echo_n "checking for CCACHE... " >&6; }
65830 65813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
65831 65814 $as_echo "disabled" >&6; }
65832 65815 else
65833 65816 # Check if the provided tool contains a complete path.
65834 65817 tool_specified="$CCACHE"
65835 65818 tool_basename="${tool_specified##*/}"
65836 65819 if test "x$tool_basename" = "x$tool_specified"; then
65837 65820 # A command without a complete path is provided, search $PATH.
65838 65821 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
65839 65822 $as_echo "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
65840 65823 # Extract the first word of "$tool_basename", so it can be a program name with args.
65841 65824 set dummy $tool_basename; ac_word=$2
65842 65825 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
65843 65826 $as_echo_n "checking for $ac_word... " >&6; }
65844 65827 if ${ac_cv_path_CCACHE+:} false; then :
65845 65828 $as_echo_n "(cached) " >&6
65846 65829 else
65847 65830 case $CCACHE in
65848 65831 [\\/]* | ?:[\\/]*)
65849 65832 ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
65850 65833 ;;
65851 65834 *)
65852 65835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
65853 65836 for as_dir in $PATH
65854 65837 do
65855 65838 IFS=$as_save_IFS
65856 65839 test -z "$as_dir" && as_dir=.
65857 65840 for ac_exec_ext in '' $ac_executable_extensions; do
65858 65841 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
65859 65842 ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
65860 65843 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
65861 65844 break 2
65862 65845 fi
65863 65846 done
65864 65847 done
65865 65848 IFS=$as_save_IFS
65866 65849
65867 65850 ;;
65868 65851 esac
65869 65852 fi
65870 65853 CCACHE=$ac_cv_path_CCACHE
65871 65854 if test -n "$CCACHE"; then
65872 65855 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
65873 65856 $as_echo "$CCACHE" >&6; }
65874 65857 else
65875 65858 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65876 65859 $as_echo "no" >&6; }
65877 65860 fi
65878 65861
65879 65862
65880 65863 if test "x$CCACHE" = x; then
65881 65864 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
65882 65865 fi
65883 65866 else
65884 65867 # Otherwise we believe it is a complete path. Use it as it is.
65885 65868 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
65886 65869 $as_echo "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
65887 65870 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
65888 65871 $as_echo_n "checking for CCACHE... " >&6; }
65889 65872 if test ! -x "$tool_specified"; then
65890 65873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
65891 65874 $as_echo "not found" >&6; }
65892 65875 as_fn_error $? "User supplied tool CCACHE=$tool_specified does not exist or is not executable" "$LINENO" 5
65893 65876 fi
65894 65877 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
65895 65878 $as_echo "$tool_specified" >&6; }
65896 65879 fi
65897 65880 fi
65898 65881 fi
65899 65882
65900 65883 fi
65901 65884
65902 65885
65903 65886
65904 65887 if test "x$CCACHE" = x; then
65905 65888 as_fn_error $? "Could not find required tool for CCACHE" "$LINENO" 5
65906 65889 fi
65907 65890
65908 65891
65909 65892 PATH="$OLD_PATH"
65910 65893 CCACHE_VERSION=`$CCACHE --version | head -n1 | $SED 's/[A-Za-z ]*//'`
65911 65894 CCACHE_STATUS="Active ($CCACHE_VERSION)"
65912 65895 else
65913 65896 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65914 65897 $as_echo "no" >&6; }
65915 65898 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: ccache is not supported with toolchain type $TOOLCHAIN_TYPE" >&5
65916 65899 $as_echo "$as_me: WARNING: ccache is not supported with toolchain type $TOOLCHAIN_TYPE" >&2;}
65917 65900 fi
65918 65901 elif test "x$enable_ccache" = xno; then
65919 65902 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
65920 65903 $as_echo "no, explicitly disabled" >&6; }
65921 65904 CCACHE_STATUS="Disabled"
65922 65905 elif test "x$enable_ccache" = x; then
65923 65906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65924 65907 $as_echo "no" >&6; }
65925 65908 else
65926 65909 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
65927 65910 $as_echo "unknown" >&6; }
65928 65911 as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
65929 65912 fi
65930 65913
65931 65914
65932 65915
65933 65916 # Check whether --with-ccache-dir was given.
65934 65917 if test "${with_ccache_dir+set}" = set; then :
65935 65918 withval=$with_ccache_dir;
65936 65919 fi
65937 65920
65938 65921
65939 65922 if test "x$with_ccache_dir" != x; then
65940 65923 # When using a non home ccache directory, assume the use is to share ccache files
65941 65924 # with other users. Thus change the umask.
65942 65925 SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002"
65943 65926 if test "x$CCACHE" = x; then
65944 65927 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
65945 65928 $as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
65946 65929 fi
65947 65930 fi
65948 65931
65949 65932 if test "x$CCACHE" != x; then
65950 65933
65951 65934 if test "x$CCACHE" != x; then
65952 65935 if test "x$USE_PRECOMPILED_HEADER" = "x1"; then
65953 65936 HAS_BAD_CCACHE=`$ECHO $CCACHE_VERSION | \
65954 65937 $GREP -e '^1.*' -e '^2.*' -e '^3\.0.*' -e '^3\.1\.[0123]$'`
65955 65938 if test "x$HAS_BAD_CCACHE" != "x"; then
65956 65939 as_fn_error $? "Precompiled headers requires ccache 3.1.4 or later, found $CCACHE_VERSION" "$LINENO" 5
65957 65940 fi
65958 65941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
65959 65942 $as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; }
65960 65943 CCACHE_PRECOMP_FLAG="-fpch-preprocess"
65961 65944 PUSHED_FLAGS="$CXXFLAGS"
65962 65945 CXXFLAGS="$CCACHE_PRECOMP_FLAG $CXXFLAGS"
65963 65946 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
65964 65947 /* end confdefs.h. */
65965 65948
65966 65949 int
65967 65950 main ()
65968 65951 {
65969 65952
65970 65953 ;
65971 65954 return 0;
65972 65955 }
65973 65956 _ACEOF
65974 65957 if ac_fn_cxx_try_compile "$LINENO"; then :
65975 65958 CC_KNOWS_CCACHE_TRICK=yes
65976 65959 else
65977 65960 CC_KNOWS_CCACHE_TRICK=no
65978 65961 fi
65979 65962 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
65980 65963 CXXFLAGS="$PUSHED_FLAGS"
65981 65964 if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then
65982 65965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
65983 65966 $as_echo "yes" >&6; }
65984 65967 CFLAGS_CCACHE="$CCACHE_PRECOMP_FLAG"
65985 65968
65986 65969 CCACHE_SLOPPINESS=pch_defines,time_macros
65987 65970 else
65988 65971 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
65989 65972 $as_echo "no" >&6; }
65990 65973 as_fn_error $? "Cannot use ccache with precompiled headers without compiler support for $CCACHE_PRECOMP_FLAG" "$LINENO" 5
65991 65974 fi
65992 65975 fi
65993 65976
65994 65977 CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR \
65995 65978 CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS CCACHE_BASEDIR=$TOPDIR $CCACHE"
65996 65979
65997 65980 if test "x$SET_CCACHE_DIR" != x; then
65998 65981 mkdir -p $CCACHE_DIR > /dev/null 2>&1
65999 65982 chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
66000 65983 fi
66001 65984 fi
66002 65985
66003 65986 fi
66004 65987
66005 65988
66006 65989 ###############################################################################
66007 65990 #
66008 65991 # And now the finish...
66009 65992 #
66010 65993 ###############################################################################
66011 65994
66012 65995 # Check for some common pitfalls
66013 65996
66014 65997 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
66015 65998 file_to_test="$SRC_ROOT/LICENSE"
66016 65999 if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
66017 66000 as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
66018 66001 fi
66019 66002 fi
66020 66003
66021 66004
66022 66005 # Did user specify any unknown variables?
66023 66006
66024 66007 if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
66025 66008 # Replace the separating ! with spaces before presenting for end user.
66026 66009 unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
66027 66010 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
66028 66011 $as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
66029 66012 fi
66030 66013
66031 66014
66032 66015 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
66033 66016 $as_echo_n "checking if build directory is on local disk... " >&6; }
66034 66017
66035 66018 # df -l lists only local disks; if the given directory is not found then
66036 66019 # a non-zero exit code is given
66037 66020 if test "x$DF" = x; then
66038 66021 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
66039 66022 # msys does not have df; use Windows "net use" instead.
66040 66023 IS_NETWORK_DISK=`net use | grep \`pwd -W | cut -d ":" -f 1 | tr a-z A-Z\`:`
66041 66024 if test "x$IS_NETWORK_DISK" = x; then
66042 66025 OUTPUT_DIR_IS_LOCAL="yes"
66043 66026 else
66044 66027 OUTPUT_DIR_IS_LOCAL="no"
66045 66028 fi
66046 66029 else
66047 66030 # No df here, say it's local
66048 66031 OUTPUT_DIR_IS_LOCAL="yes"
66049 66032 fi
66050 66033 else
66051 66034 if $DF -l $OUTPUT_ROOT > /dev/null 2>&1; then
66052 66035 OUTPUT_DIR_IS_LOCAL="yes"
66053 66036 else
66054 66037 OUTPUT_DIR_IS_LOCAL="no"
66055 66038 fi
66056 66039 fi
66057 66040
66058 66041 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
66059 66042 $as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; }
66060 66043
66061 66044
66062 66045
66063 66046 # Check if the user has any old-style ALT_ variables set.
66064 66047 FOUND_ALT_VARIABLES=`env | grep ^ALT_`
66065 66048
66066 66049 # Before generating output files, test if they exist. If they do, this is a reconfigure.
66067 66050 # Since we can't properly handle the dependencies for this, warn the user about the situation
66068 66051 if test -e $OUTPUT_ROOT/spec.gmk; then
66069 66052 IS_RECONFIGURE=yes
66070 66053 else
66071 66054 IS_RECONFIGURE=no
66072 66055 fi
66073 66056
66074 66057
66075 66058 # At the end, call the custom hook. (Dummy macro if no custom sources available)
66076 66059
66077 66060
66078 66061 # This needs to be done after CUSTOM_LATE_HOOK since we can setup custom features.
66079 66062
66080 66063 # Keep feature lists sorted and free of duplicates
66081 66064 JVM_FEATURES_server="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_server | $SORT -u))"
66082 66065 JVM_FEATURES_client="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_client | $SORT -u))"
66083 66066 JVM_FEATURES_core="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_core | $SORT -u))"
66084 66067 JVM_FEATURES_minimal="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_minimal | $SORT -u))"
66085 66068 JVM_FEATURES_zero="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zero | $SORT -u))"
66086 66069 JVM_FEATURES_zeroshark="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zeroshark | $SORT -u))"
66087 66070 JVM_FEATURES_custom="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_custom | $SORT -u))"
66088 66071
66089 66072 # Validate features
66090 66073 for variant in $JVM_VARIANTS; do
66091 66074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking JVM features for JVM variant '$variant'" >&5
66092 66075 $as_echo_n "checking JVM features for JVM variant '$variant'... " >&6; }
66093 66076 features_var_name=JVM_FEATURES_$variant
66094 66077 JVM_FEATURES_TO_TEST=${!features_var_name}
66095 66078 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_FEATURES_TO_TEST" >&5
66096 66079 $as_echo "$JVM_FEATURES_TO_TEST" >&6; }
66097 66080 NEEDLE=${VALID_JVM_FEATURES// /$'\n'}
66098 66081 STACK=${JVM_FEATURES_TO_TEST// /$'\n'}
66099 66082 INVALID_FEATURES=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
66100 66083 if test "x$INVALID_FEATURES" != x; then
66101 66084 as_fn_error $? "Invalid JVM feature(s): $INVALID_FEATURES" "$LINENO" 5
66102 66085 fi
66103 66086 done
66104 66087
66105 66088
66106 66089 # We're messing a bit with internal autoconf variables to put the config.status
66107 66090 # in the output directory instead of the current directory.
66108 66091 CONFIG_STATUS="$CONFIGURESUPPORT_OUTPUTDIR/config.status"
66109 66092
66110 66093 # Create the actual output files. Now the main work of configure is done.
66111 66094 cat >confcache <<\_ACEOF
66112 66095 # This file is a shell script that caches the results of configure
66113 66096 # tests run on this system so they can be shared between configure
66114 66097 # scripts and configure runs, see configure's option --config-cache.
66115 66098 # It is not useful on other systems. If it contains results you don't
66116 66099 # want to keep, you may remove or edit it.
66117 66100 #
66118 66101 # config.status only pays attention to the cache file if you give it
66119 66102 # the --recheck option to rerun configure.
66120 66103 #
66121 66104 # `ac_cv_env_foo' variables (set or unset) will be overridden when
66122 66105 # loading this file, other *unset* `ac_cv_foo' will be assigned the
66123 66106 # following values.
66124 66107
66125 66108 _ACEOF
66126 66109
66127 66110 # The following way of writing the cache mishandles newlines in values,
66128 66111 # but we know of no workaround that is simple, portable, and efficient.
66129 66112 # So, we kill variables containing newlines.
66130 66113 # Ultrix sh set writes to stderr and can't be redirected directly,
66131 66114 # and sets the high bit in the cache file unless we assign to the vars.
66132 66115 (
66133 66116 for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
66134 66117 eval ac_val=\$$ac_var
66135 66118 case $ac_val in #(
66136 66119 *${as_nl}*)
66137 66120 case $ac_var in #(
66138 66121 *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
66139 66122 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
66140 66123 esac
66141 66124 case $ac_var in #(
66142 66125 _ | IFS | as_nl) ;; #(
66143 66126 BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
66144 66127 *) { eval $ac_var=; unset $ac_var;} ;;
66145 66128 esac ;;
66146 66129 esac
66147 66130 done
66148 66131
66149 66132 (set) 2>&1 |
66150 66133 case $as_nl`(ac_space=' '; set) 2>&1` in #(
66151 66134 *${as_nl}ac_space=\ *)
66152 66135 # `set' does not quote correctly, so add quotes: double-quote
66153 66136 # substitution turns \\\\ into \\, and sed turns \\ into \.
66154 66137 sed -n \
66155 66138 "s/'/'\\\\''/g;
66156 66139 s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
66157 66140 ;; #(
66158 66141 *)
66159 66142 # `set' quotes correctly as required by POSIX, so do not add quotes.
66160 66143 sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
66161 66144 ;;
66162 66145 esac |
66163 66146 sort
66164 66147 ) |
66165 66148 sed '
66166 66149 /^ac_cv_env_/b end
66167 66150 t clear
66168 66151 :clear
66169 66152 s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
66170 66153 t end
66171 66154 s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
66172 66155 :end' >>confcache
66173 66156 if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
66174 66157 if test -w "$cache_file"; then
66175 66158 if test "x$cache_file" != "x/dev/null"; then
66176 66159 { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
66177 66160 $as_echo "$as_me: updating cache $cache_file" >&6;}
66178 66161 if test ! -f "$cache_file" || test -h "$cache_file"; then
66179 66162 cat confcache >"$cache_file"
66180 66163 else
66181 66164 case $cache_file in #(
66182 66165 */* | ?:*)
66183 66166 mv -f confcache "$cache_file"$$ &&
66184 66167 mv -f "$cache_file"$$ "$cache_file" ;; #(
66185 66168 *)
66186 66169 mv -f confcache "$cache_file" ;;
66187 66170 esac
66188 66171 fi
66189 66172 fi
66190 66173 else
66191 66174 { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
66192 66175 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
66193 66176 fi
66194 66177 fi
66195 66178 rm -f confcache
66196 66179
66197 66180 test "x$prefix" = xNONE && prefix=$ac_default_prefix
66198 66181 # Let make expand exec_prefix.
66199 66182 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
66200 66183
66201 66184 # Transform confdefs.h into DEFS.
66202 66185 # Protect against shell expansion while executing Makefile rules.
66203 66186 # Protect against Makefile macro expansion.
66204 66187 #
66205 66188 # If the first sed substitution is executed (which looks for macros that
66206 66189 # take arguments), then branch to the quote section. Otherwise,
66207 66190 # look for a macro that doesn't take arguments.
66208 66191 ac_script='
66209 66192 :mline
66210 66193 /\\$/{
66211 66194 N
66212 66195 s,\\\n,,
66213 66196 b mline
66214 66197 }
66215 66198 t clear
66216 66199 :clear
66217 66200 s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g
66218 66201 t quote
66219 66202 s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g
66220 66203 t quote
66221 66204 b any
66222 66205 :quote
66223 66206 s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g
66224 66207 s/\[/\\&/g
66225 66208 s/\]/\\&/g
66226 66209 s/\$/$$/g
66227 66210 H
66228 66211 :any
66229 66212 ${
66230 66213 g
66231 66214 s/^\n//
66232 66215 s/\n/ /g
66233 66216 p
66234 66217 }
66235 66218 '
66236 66219 DEFS=`sed -n "$ac_script" confdefs.h`
66237 66220
66238 66221
66239 66222 ac_libobjs=
66240 66223 ac_ltlibobjs=
66241 66224 U=
66242 66225 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
66243 66226 # 1. Remove the extension, and $U if already installed.
66244 66227 ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
66245 66228 ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
66246 66229 # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
66247 66230 # will be set to the directory where LIBOBJS objects are built.
66248 66231 as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
66249 66232 as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
66250 66233 done
66251 66234 LIBOBJS=$ac_libobjs
66252 66235
66253 66236 LTLIBOBJS=$ac_ltlibobjs
66254 66237
66255 66238
66256 66239
66257 66240 : "${CONFIG_STATUS=./config.status}"
66258 66241 ac_write_fail=0
66259 66242 ac_clean_files_save=$ac_clean_files
66260 66243 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
66261 66244 { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
66262 66245 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
66263 66246 as_write_fail=0
66264 66247 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
66265 66248 #! $SHELL
66266 66249 # Generated by $as_me.
66267 66250 # Run this file to recreate the current configuration.
66268 66251 # Compiler output produced by configure, useful for debugging
66269 66252 # configure, is in config.log if it exists.
66270 66253
66271 66254 debug=false
66272 66255 ac_cs_recheck=false
66273 66256 ac_cs_silent=false
66274 66257
66275 66258 SHELL=\${CONFIG_SHELL-$SHELL}
66276 66259 export SHELL
66277 66260 _ASEOF
66278 66261 cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
66279 66262 ## -------------------- ##
66280 66263 ## M4sh Initialization. ##
66281 66264 ## -------------------- ##
66282 66265
66283 66266 # Be more Bourne compatible
66284 66267 DUALCASE=1; export DUALCASE # for MKS sh
66285 66268 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
66286 66269 emulate sh
66287 66270 NULLCMD=:
66288 66271 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
66289 66272 # is contrary to our usage. Disable this feature.
66290 66273 alias -g '${1+"$@"}'='"$@"'
66291 66274 setopt NO_GLOB_SUBST
66292 66275 else
66293 66276 case `(set -o) 2>/dev/null` in #(
66294 66277 *posix*) :
66295 66278 set -o posix ;; #(
66296 66279 *) :
66297 66280 ;;
66298 66281 esac
66299 66282 fi
66300 66283
66301 66284
66302 66285 as_nl='
66303 66286 '
66304 66287 export as_nl
66305 66288 # Printing a long string crashes Solaris 7 /usr/bin/printf.
66306 66289 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
66307 66290 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
66308 66291 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
66309 66292 # Prefer a ksh shell builtin over an external printf program on Solaris,
66310 66293 # but without wasting forks for bash or zsh.
66311 66294 if test -z "$BASH_VERSION$ZSH_VERSION" \
66312 66295 && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
66313 66296 as_echo='print -r --'
66314 66297 as_echo_n='print -rn --'
66315 66298 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
66316 66299 as_echo='printf %s\n'
66317 66300 as_echo_n='printf %s'
66318 66301 else
66319 66302 if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
66320 66303 as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
66321 66304 as_echo_n='/usr/ucb/echo -n'
66322 66305 else
66323 66306 as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
66324 66307 as_echo_n_body='eval
66325 66308 arg=$1;
66326 66309 case $arg in #(
66327 66310 *"$as_nl"*)
66328 66311 expr "X$arg" : "X\\(.*\\)$as_nl";
66329 66312 arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
66330 66313 esac;
66331 66314 expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
66332 66315 '
66333 66316 export as_echo_n_body
66334 66317 as_echo_n='sh -c $as_echo_n_body as_echo'
66335 66318 fi
66336 66319 export as_echo_body
66337 66320 as_echo='sh -c $as_echo_body as_echo'
66338 66321 fi
66339 66322
66340 66323 # The user is always right.
66341 66324 if test "${PATH_SEPARATOR+set}" != set; then
66342 66325 PATH_SEPARATOR=:
66343 66326 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
66344 66327 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
66345 66328 PATH_SEPARATOR=';'
66346 66329 }
66347 66330 fi
66348 66331
66349 66332
66350 66333 # IFS
66351 66334 # We need space, tab and new line, in precisely that order. Quoting is
66352 66335 # there to prevent editors from complaining about space-tab.
66353 66336 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
66354 66337 # splitting by setting IFS to empty value.)
66355 66338 IFS=" "" $as_nl"
66356 66339
66357 66340 # Find who we are. Look in the path if we contain no directory separator.
66358 66341 as_myself=
66359 66342 case $0 in #((
66360 66343 *[\\/]* ) as_myself=$0 ;;
66361 66344 *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
66362 66345 for as_dir in $PATH
66363 66346 do
66364 66347 IFS=$as_save_IFS
66365 66348 test -z "$as_dir" && as_dir=.
66366 66349 test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
66367 66350 done
66368 66351 IFS=$as_save_IFS
66369 66352
66370 66353 ;;
66371 66354 esac
66372 66355 # We did not find ourselves, most probably we were run as `sh COMMAND'
66373 66356 # in which case we are not to be found in the path.
66374 66357 if test "x$as_myself" = x; then
66375 66358 as_myself=$0
66376 66359 fi
66377 66360 if test ! -f "$as_myself"; then
66378 66361 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
66379 66362 exit 1
66380 66363 fi
66381 66364
66382 66365 # Unset variables that we do not need and which cause bugs (e.g. in
66383 66366 # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
66384 66367 # suppresses any "Segmentation fault" message there. '((' could
66385 66368 # trigger a bug in pdksh 5.2.14.
66386 66369 for as_var in BASH_ENV ENV MAIL MAILPATH
66387 66370 do eval test x\${$as_var+set} = xset \
66388 66371 && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
66389 66372 done
66390 66373 PS1='$ '
66391 66374 PS2='> '
66392 66375 PS4='+ '
66393 66376
66394 66377 # NLS nuisances.
66395 66378 LC_ALL=C
66396 66379 export LC_ALL
66397 66380 LANGUAGE=C
66398 66381 export LANGUAGE
66399 66382
66400 66383 # CDPATH.
66401 66384 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
66402 66385
66403 66386
66404 66387 # as_fn_error STATUS ERROR [LINENO LOG_FD]
66405 66388 # ----------------------------------------
66406 66389 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
66407 66390 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
66408 66391 # script with STATUS, using 1 if that was 0.
66409 66392 as_fn_error ()
66410 66393 {
66411 66394 as_status=$1; test $as_status -eq 0 && as_status=1
66412 66395 if test "$4"; then
66413 66396 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
66414 66397 $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
66415 66398 fi
66416 66399 $as_echo "$as_me: error: $2" >&2
66417 66400 as_fn_exit $as_status
66418 66401 } # as_fn_error
66419 66402
66420 66403
66421 66404 # as_fn_set_status STATUS
66422 66405 # -----------------------
66423 66406 # Set $? to STATUS, without forking.
66424 66407 as_fn_set_status ()
66425 66408 {
66426 66409 return $1
66427 66410 } # as_fn_set_status
66428 66411
66429 66412 # as_fn_exit STATUS
66430 66413 # -----------------
66431 66414 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
66432 66415 as_fn_exit ()
66433 66416 {
66434 66417 set +e
66435 66418 as_fn_set_status $1
66436 66419 exit $1
66437 66420 } # as_fn_exit
66438 66421
66439 66422 # as_fn_unset VAR
66440 66423 # ---------------
66441 66424 # Portably unset VAR.
66442 66425 as_fn_unset ()
66443 66426 {
66444 66427 { eval $1=; unset $1;}
66445 66428 }
66446 66429 as_unset=as_fn_unset
66447 66430 # as_fn_append VAR VALUE
66448 66431 # ----------------------
66449 66432 # Append the text in VALUE to the end of the definition contained in VAR. Take
66450 66433 # advantage of any shell optimizations that allow amortized linear growth over
66451 66434 # repeated appends, instead of the typical quadratic growth present in naive
66452 66435 # implementations.
66453 66436 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
66454 66437 eval 'as_fn_append ()
66455 66438 {
66456 66439 eval $1+=\$2
66457 66440 }'
66458 66441 else
66459 66442 as_fn_append ()
66460 66443 {
66461 66444 eval $1=\$$1\$2
66462 66445 }
66463 66446 fi # as_fn_append
66464 66447
66465 66448 # as_fn_arith ARG...
66466 66449 # ------------------
66467 66450 # Perform arithmetic evaluation on the ARGs, and store the result in the
66468 66451 # global $as_val. Take advantage of shells that can avoid forks. The arguments
66469 66452 # must be portable across $(()) and expr.
66470 66453 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
66471 66454 eval 'as_fn_arith ()
66472 66455 {
66473 66456 as_val=$(( $* ))
66474 66457 }'
66475 66458 else
66476 66459 as_fn_arith ()
66477 66460 {
66478 66461 as_val=`expr "$@" || test $? -eq 1`
66479 66462 }
66480 66463 fi # as_fn_arith
66481 66464
66482 66465
66483 66466 if expr a : '\(a\)' >/dev/null 2>&1 &&
66484 66467 test "X`expr 00001 : '.*\(...\)'`" = X001; then
66485 66468 as_expr=expr
66486 66469 else
66487 66470 as_expr=false
66488 66471 fi
66489 66472
66490 66473 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
66491 66474 as_basename=basename
66492 66475 else
66493 66476 as_basename=false
66494 66477 fi
66495 66478
66496 66479 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
66497 66480 as_dirname=dirname
66498 66481 else
66499 66482 as_dirname=false
66500 66483 fi
66501 66484
66502 66485 as_me=`$as_basename -- "$0" ||
66503 66486 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
66504 66487 X"$0" : 'X\(//\)$' \| \
66505 66488 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
66506 66489 $as_echo X/"$0" |
66507 66490 sed '/^.*\/\([^/][^/]*\)\/*$/{
66508 66491 s//\1/
66509 66492 q
66510 66493 }
66511 66494 /^X\/\(\/\/\)$/{
66512 66495 s//\1/
66513 66496 q
66514 66497 }
66515 66498 /^X\/\(\/\).*/{
66516 66499 s//\1/
66517 66500 q
66518 66501 }
66519 66502 s/.*/./; q'`
66520 66503
66521 66504 # Avoid depending upon Character Ranges.
66522 66505 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
66523 66506 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
66524 66507 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
66525 66508 as_cr_digits='0123456789'
66526 66509 as_cr_alnum=$as_cr_Letters$as_cr_digits
66527 66510
66528 66511 ECHO_C= ECHO_N= ECHO_T=
66529 66512 case `echo -n x` in #(((((
66530 66513 -n*)
66531 66514 case `echo 'xy\c'` in
66532 66515 *c*) ECHO_T=' ';; # ECHO_T is single tab character.
66533 66516 xy) ECHO_C='\c';;
66534 66517 *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
66535 66518 ECHO_T=' ';;
66536 66519 esac;;
66537 66520 *)
66538 66521 ECHO_N='-n';;
66539 66522 esac
66540 66523
66541 66524 rm -f conf$$ conf$$.exe conf$$.file
66542 66525 if test -d conf$$.dir; then
66543 66526 rm -f conf$$.dir/conf$$.file
66544 66527 else
66545 66528 rm -f conf$$.dir
66546 66529 mkdir conf$$.dir 2>/dev/null
66547 66530 fi
66548 66531 if (echo >conf$$.file) 2>/dev/null; then
66549 66532 if ln -s conf$$.file conf$$ 2>/dev/null; then
66550 66533 as_ln_s='ln -s'
66551 66534 # ... but there are two gotchas:
66552 66535 # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
66553 66536 # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
66554 66537 # In both cases, we have to default to `cp -pR'.
66555 66538 ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
66556 66539 as_ln_s='cp -pR'
66557 66540 elif ln conf$$.file conf$$ 2>/dev/null; then
66558 66541 as_ln_s=ln
66559 66542 else
66560 66543 as_ln_s='cp -pR'
66561 66544 fi
66562 66545 else
66563 66546 as_ln_s='cp -pR'
66564 66547 fi
66565 66548 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
66566 66549 rmdir conf$$.dir 2>/dev/null
66567 66550
66568 66551
66569 66552 # as_fn_mkdir_p
66570 66553 # -------------
66571 66554 # Create "$as_dir" as a directory, including parents if necessary.
66572 66555 as_fn_mkdir_p ()
66573 66556 {
66574 66557
66575 66558 case $as_dir in #(
66576 66559 -*) as_dir=./$as_dir;;
66577 66560 esac
66578 66561 test -d "$as_dir" || eval $as_mkdir_p || {
66579 66562 as_dirs=
66580 66563 while :; do
66581 66564 case $as_dir in #(
66582 66565 *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
66583 66566 *) as_qdir=$as_dir;;
66584 66567 esac
66585 66568 as_dirs="'$as_qdir' $as_dirs"
66586 66569 as_dir=`$as_dirname -- "$as_dir" ||
66587 66570 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
66588 66571 X"$as_dir" : 'X\(//\)[^/]' \| \
66589 66572 X"$as_dir" : 'X\(//\)$' \| \
66590 66573 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
66591 66574 $as_echo X"$as_dir" |
66592 66575 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
66593 66576 s//\1/
66594 66577 q
66595 66578 }
66596 66579 /^X\(\/\/\)[^/].*/{
66597 66580 s//\1/
66598 66581 q
66599 66582 }
66600 66583 /^X\(\/\/\)$/{
66601 66584 s//\1/
66602 66585 q
66603 66586 }
66604 66587 /^X\(\/\).*/{
66605 66588 s//\1/
66606 66589 q
66607 66590 }
66608 66591 s/.*/./; q'`
66609 66592 test -d "$as_dir" && break
66610 66593 done
66611 66594 test -z "$as_dirs" || eval "mkdir $as_dirs"
66612 66595 } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
66613 66596
66614 66597
66615 66598 } # as_fn_mkdir_p
66616 66599 if mkdir -p . 2>/dev/null; then
66617 66600 as_mkdir_p='mkdir -p "$as_dir"'
66618 66601 else
66619 66602 test -d ./-p && rmdir ./-p
66620 66603 as_mkdir_p=false
66621 66604 fi
66622 66605
66623 66606
66624 66607 # as_fn_executable_p FILE
66625 66608 # -----------------------
66626 66609 # Test if FILE is an executable regular file.
66627 66610 as_fn_executable_p ()
66628 66611 {
66629 66612 test -f "$1" && test -x "$1"
66630 66613 } # as_fn_executable_p
66631 66614 as_test_x='test -x'
66632 66615 as_executable_p=as_fn_executable_p
66633 66616
66634 66617 # Sed expression to map a string onto a valid CPP name.
66635 66618 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
66636 66619
66637 66620 # Sed expression to map a string onto a valid variable name.
66638 66621 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
66639 66622
66640 66623
66641 66624 exec 6>&1
66642 66625 ## ----------------------------------- ##
66643 66626 ## Main body of $CONFIG_STATUS script. ##
66644 66627 ## ----------------------------------- ##
66645 66628 _ASEOF
66646 66629 test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
66647 66630
66648 66631 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66649 66632 # Save the log message, to keep $0 and so on meaningful, and to
66650 66633 # report actual input values of CONFIG_FILES etc. instead of their
66651 66634 # values after options handling.
66652 66635 ac_log="
66653 66636 This file was extended by OpenJDK $as_me jdk9, which was
66654 66637 generated by GNU Autoconf 2.69. Invocation command line was
66655 66638
66656 66639 CONFIG_FILES = $CONFIG_FILES
66657 66640 CONFIG_HEADERS = $CONFIG_HEADERS
66658 66641 CONFIG_LINKS = $CONFIG_LINKS
66659 66642 CONFIG_COMMANDS = $CONFIG_COMMANDS
66660 66643 $ $0 $@
66661 66644
66662 66645 on `(hostname || uname -n) 2>/dev/null | sed 1q`
66663 66646 "
66664 66647
66665 66648 _ACEOF
66666 66649
66667 66650 case $ac_config_files in *"
66668 66651 "*) set x $ac_config_files; shift; ac_config_files=$*;;
66669 66652 esac
66670 66653
66671 66654
66672 66655
66673 66656 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66674 66657 # Files that config.status was made for.
66675 66658 config_files="$ac_config_files"
66676 66659
66677 66660 _ACEOF
66678 66661
66679 66662 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66680 66663 ac_cs_usage="\
66681 66664 \`$as_me' instantiates files and other configuration actions
66682 66665 from templates according to the current configuration. Unless the files
66683 66666 and actions are specified as TAGs, all are instantiated by default.
66684 66667
66685 66668 Usage: $0 [OPTION]... [TAG]...
66686 66669
66687 66670 -h, --help print this help, then exit
66688 66671 -V, --version print version number and configuration settings, then exit
66689 66672 --config print configuration, then exit
66690 66673 -q, --quiet, --silent
66691 66674 do not print progress messages
66692 66675 -d, --debug don't remove temporary files
66693 66676 --recheck update $as_me by reconfiguring in the same conditions
66694 66677 --file=FILE[:TEMPLATE]
66695 66678 instantiate the configuration file FILE
66696 66679
66697 66680 Configuration files:
66698 66681 $config_files
66699 66682
66700 66683 Report bugs to <build-dev@openjdk.java.net>.
66701 66684 OpenJDK home page: <http://openjdk.java.net>."
66702 66685
66703 66686 _ACEOF
66704 66687 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66705 66688 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
66706 66689 ac_cs_version="\\
66707 66690 OpenJDK config.status jdk9
66708 66691 configured by $0, generated by GNU Autoconf 2.69,
66709 66692 with options \\"\$ac_cs_config\\"
66710 66693
66711 66694 Copyright (C) 2012 Free Software Foundation, Inc.
66712 66695 This config.status script is free software; the Free Software Foundation
66713 66696 gives unlimited permission to copy, distribute and modify it."
66714 66697
66715 66698 ac_pwd='$ac_pwd'
66716 66699 srcdir='$srcdir'
66717 66700 AWK='$AWK'
66718 66701 test -n "\$AWK" || AWK=awk
66719 66702 _ACEOF
66720 66703
66721 66704 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66722 66705 # The default lists apply if the user does not specify any file.
66723 66706 ac_need_defaults=:
66724 66707 while test $# != 0
66725 66708 do
66726 66709 case $1 in
66727 66710 --*=?*)
66728 66711 ac_option=`expr "X$1" : 'X\([^=]*\)='`
66729 66712 ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
66730 66713 ac_shift=:
66731 66714 ;;
66732 66715 --*=)
66733 66716 ac_option=`expr "X$1" : 'X\([^=]*\)='`
66734 66717 ac_optarg=
66735 66718 ac_shift=:
66736 66719 ;;
66737 66720 *)
66738 66721 ac_option=$1
66739 66722 ac_optarg=$2
66740 66723 ac_shift=shift
66741 66724 ;;
66742 66725 esac
66743 66726
66744 66727 case $ac_option in
66745 66728 # Handling of the options.
66746 66729 -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
66747 66730 ac_cs_recheck=: ;;
66748 66731 --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
66749 66732 $as_echo "$ac_cs_version"; exit ;;
66750 66733 --config | --confi | --conf | --con | --co | --c )
66751 66734 $as_echo "$ac_cs_config"; exit ;;
66752 66735 --debug | --debu | --deb | --de | --d | -d )
66753 66736 debug=: ;;
66754 66737 --file | --fil | --fi | --f )
66755 66738 $ac_shift
66756 66739 case $ac_optarg in
66757 66740 *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
66758 66741 '') as_fn_error $? "missing file argument" ;;
66759 66742 esac
66760 66743 as_fn_append CONFIG_FILES " '$ac_optarg'"
66761 66744 ac_need_defaults=false;;
66762 66745 --he | --h | --help | --hel | -h )
66763 66746 $as_echo "$ac_cs_usage"; exit ;;
66764 66747 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
66765 66748 | -silent | --silent | --silen | --sile | --sil | --si | --s)
66766 66749 ac_cs_silent=: ;;
66767 66750
66768 66751 # This is an error.
66769 66752 -*) as_fn_error $? "unrecognized option: \`$1'
66770 66753 Try \`$0 --help' for more information." ;;
66771 66754
66772 66755 *) as_fn_append ac_config_targets " $1"
66773 66756 ac_need_defaults=false ;;
66774 66757
66775 66758 esac
66776 66759 shift
66777 66760 done
66778 66761
66779 66762 ac_configure_extra_args=
66780 66763
66781 66764 if $ac_cs_silent; then
66782 66765 exec 6>/dev/null
66783 66766 ac_configure_extra_args="$ac_configure_extra_args --silent"
66784 66767 fi
66785 66768
66786 66769 _ACEOF
66787 66770 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66788 66771 if \$ac_cs_recheck; then
66789 66772 set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
66790 66773 shift
66791 66774 \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
66792 66775 CONFIG_SHELL='$SHELL'
66793 66776 export CONFIG_SHELL
66794 66777 exec "\$@"
66795 66778 fi
66796 66779
66797 66780 _ACEOF
66798 66781 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66799 66782 exec 5>>config.log
66800 66783 {
66801 66784 echo
66802 66785 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
66803 66786 ## Running $as_me. ##
66804 66787 _ASBOX
66805 66788 $as_echo "$ac_log"
66806 66789 } >&5
66807 66790
66808 66791 _ACEOF
66809 66792 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66810 66793 _ACEOF
66811 66794
66812 66795 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66813 66796
66814 66797 # Handling of arguments.
66815 66798 for ac_config_target in $ac_config_targets
66816 66799 do
66817 66800 case $ac_config_target in
66818 66801 "$OUTPUT_ROOT/spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" ;;
66819 66802 "$OUTPUT_ROOT/bootcycle-spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in" ;;
66820 66803 "$OUTPUT_ROOT/buildjdk-spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in" ;;
66821 66804 "$OUTPUT_ROOT/compare.sh") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in" ;;
66822 66805 "$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;;
66823 66806
66824 66807 *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
66825 66808 esac
66826 66809 done
66827 66810
66828 66811
66829 66812 # If the user did not use the arguments to specify the items to instantiate,
66830 66813 # then the envvar interface is used. Set only those that are not.
66831 66814 # We use the long form for the default assignment because of an extremely
66832 66815 # bizarre bug on SunOS 4.1.3.
66833 66816 if $ac_need_defaults; then
66834 66817 test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
66835 66818 fi
66836 66819
66837 66820 # Have a temporary directory for convenience. Make it in the build tree
66838 66821 # simply because there is no reason against having it here, and in addition,
66839 66822 # creating and moving files from /tmp can sometimes cause problems.
66840 66823 # Hook for its removal unless debugging.
66841 66824 # Note that there is a small window in which the directory will not be cleaned:
66842 66825 # after its creation but before its name has been assigned to `$tmp'.
66843 66826 $debug ||
66844 66827 {
66845 66828 tmp= ac_tmp=
66846 66829 trap 'exit_status=$?
66847 66830 : "${ac_tmp:=$tmp}"
66848 66831 { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
66849 66832 ' 0
66850 66833 trap 'as_fn_exit 1' 1 2 13 15
66851 66834 }
66852 66835 # Create a (secure) tmp directory for tmp files.
66853 66836
66854 66837 {
66855 66838 tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
66856 66839 test -d "$tmp"
66857 66840 } ||
66858 66841 {
66859 66842 tmp=./conf$$-$RANDOM
66860 66843 (umask 077 && mkdir "$tmp")
66861 66844 } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
66862 66845 ac_tmp=$tmp
66863 66846
66864 66847 # Set up the scripts for CONFIG_FILES section.
66865 66848 # No need to generate them if there are no CONFIG_FILES.
66866 66849 # This happens for instance with `./config.status config.h'.
66867 66850 if test -n "$CONFIG_FILES"; then
66868 66851
66869 66852
66870 66853 ac_cr=`echo X | tr X '\015'`
66871 66854 # On cygwin, bash can eat \r inside `` if the user requested igncr.
66872 66855 # But we know of no other shell where ac_cr would be empty at this
66873 66856 # point, so we can use a bashism as a fallback.
66874 66857 if test "x$ac_cr" = x; then
66875 66858 eval ac_cr=\$\'\\r\'
66876 66859 fi
66877 66860 ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
66878 66861 if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
66879 66862 ac_cs_awk_cr='\\r'
66880 66863 else
66881 66864 ac_cs_awk_cr=$ac_cr
66882 66865 fi
66883 66866
66884 66867 echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
66885 66868 _ACEOF
66886 66869
66887 66870
66888 66871 {
66889 66872 echo "cat >conf$$subs.awk <<_ACEOF" &&
66890 66873 echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
66891 66874 echo "_ACEOF"
66892 66875 } >conf$$subs.sh ||
66893 66876 as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
66894 66877 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
66895 66878 ac_delim='%!_!# '
66896 66879 for ac_last_try in false false false false false :; do
66897 66880 . ./conf$$subs.sh ||
66898 66881 as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
66899 66882
66900 66883 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
66901 66884 if test $ac_delim_n = $ac_delim_num; then
66902 66885 break
66903 66886 elif $ac_last_try; then
66904 66887 as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
66905 66888 else
66906 66889 ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
66907 66890 fi
66908 66891 done
66909 66892 rm -f conf$$subs.sh
66910 66893
66911 66894 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66912 66895 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
66913 66896 _ACEOF
66914 66897 sed -n '
66915 66898 h
66916 66899 s/^/S["/; s/!.*/"]=/
66917 66900 p
66918 66901 g
66919 66902 s/^[^!]*!//
66920 66903 :repl
66921 66904 t repl
66922 66905 s/'"$ac_delim"'$//
66923 66906 t delim
66924 66907 :nl
66925 66908 h
66926 66909 s/\(.\{148\}\)..*/\1/
66927 66910 t more1
66928 66911 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
66929 66912 p
66930 66913 n
66931 66914 b repl
66932 66915 :more1
66933 66916 s/["\\]/\\&/g; s/^/"/; s/$/"\\/
66934 66917 p
66935 66918 g
66936 66919 s/.\{148\}//
66937 66920 t nl
66938 66921 :delim
66939 66922 h
66940 66923 s/\(.\{148\}\)..*/\1/
66941 66924 t more2
66942 66925 s/["\\]/\\&/g; s/^/"/; s/$/"/
66943 66926 p
66944 66927 b
66945 66928 :more2
66946 66929 s/["\\]/\\&/g; s/^/"/; s/$/"\\/
66947 66930 p
66948 66931 g
66949 66932 s/.\{148\}//
66950 66933 t delim
66951 66934 ' <conf$$subs.awk | sed '
66952 66935 /^[^""]/{
66953 66936 N
66954 66937 s/\n//
66955 66938 }
66956 66939 ' >>$CONFIG_STATUS || ac_write_fail=1
66957 66940 rm -f conf$$subs.awk
66958 66941 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
66959 66942 _ACAWK
66960 66943 cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
66961 66944 for (key in S) S_is_set[key] = 1
66962 66945 FS = ""
66963 66946
66964 66947 }
66965 66948 {
66966 66949 line = $ 0
66967 66950 nfields = split(line, field, "@")
66968 66951 substed = 0
66969 66952 len = length(field[1])
66970 66953 for (i = 2; i < nfields; i++) {
66971 66954 key = field[i]
66972 66955 keylen = length(key)
66973 66956 if (S_is_set[key]) {
66974 66957 value = S[key]
66975 66958 line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
66976 66959 len += length(value) + length(field[++i])
66977 66960 substed = 1
66978 66961 } else
66979 66962 len += 1 + keylen
66980 66963 }
66981 66964
66982 66965 print line
66983 66966 }
66984 66967
66985 66968 _ACAWK
66986 66969 _ACEOF
66987 66970 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
66988 66971 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
66989 66972 sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
66990 66973 else
66991 66974 cat
66992 66975 fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
66993 66976 || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
66994 66977 _ACEOF
66995 66978
66996 66979 # VPATH may cause trouble with some makes, so we remove sole $(srcdir),
66997 66980 # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
66998 66981 # trailing colons and then remove the whole line if VPATH becomes empty
66999 66982 # (actually we leave an empty line to preserve line numbers).
67000 66983 if test "x$srcdir" = x.; then
67001 66984 ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{
67002 66985 h
67003 66986 s///
67004 66987 s/^/:/
67005 66988 s/[ ]*$/:/
67006 66989 s/:\$(srcdir):/:/g
67007 66990 s/:\${srcdir}:/:/g
67008 66991 s/:@srcdir@:/:/g
67009 66992 s/^:*//
67010 66993 s/:*$//
67011 66994 x
67012 66995 s/\(=[ ]*\).*/\1/
67013 66996 G
67014 66997 s/\n//
67015 66998 s/^[^=]*=[ ]*$//
67016 66999 }'
67017 67000 fi
67018 67001
67019 67002 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
67020 67003 fi # test -n "$CONFIG_FILES"
67021 67004
67022 67005
67023 67006 eval set X " :F $CONFIG_FILES "
67024 67007 shift
67025 67008 for ac_tag
67026 67009 do
67027 67010 case $ac_tag in
67028 67011 :[FHLC]) ac_mode=$ac_tag; continue;;
67029 67012 esac
67030 67013 case $ac_mode$ac_tag in
67031 67014 :[FHL]*:*);;
67032 67015 :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
67033 67016 :[FH]-) ac_tag=-:-;;
67034 67017 :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
67035 67018 esac
67036 67019 ac_save_IFS=$IFS
67037 67020 IFS=:
67038 67021 set x $ac_tag
67039 67022 IFS=$ac_save_IFS
67040 67023 shift
67041 67024 ac_file=$1
67042 67025 shift
67043 67026
67044 67027 case $ac_mode in
67045 67028 :L) ac_source=$1;;
67046 67029 :[FH])
67047 67030 ac_file_inputs=
67048 67031 for ac_f
67049 67032 do
67050 67033 case $ac_f in
67051 67034 -) ac_f="$ac_tmp/stdin";;
67052 67035 *) # Look for the file first in the build tree, then in the source tree
67053 67036 # (if the path is not absolute). The absolute path cannot be DOS-style,
67054 67037 # because $ac_f cannot contain `:'.
67055 67038 test -f "$ac_f" ||
67056 67039 case $ac_f in
67057 67040 [\\/$]*) false;;
67058 67041 *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
67059 67042 esac ||
67060 67043 as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
67061 67044 esac
67062 67045 case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
67063 67046 as_fn_append ac_file_inputs " '$ac_f'"
67064 67047 done
67065 67048
67066 67049 # Let's still pretend it is `configure' which instantiates (i.e., don't
67067 67050 # use $as_me), people would be surprised to read:
67068 67051 # /* config.h. Generated by config.status. */
67069 67052 configure_input='Generated from '`
67070 67053 $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
67071 67054 `' by configure.'
67072 67055 if test x"$ac_file" != x-; then
67073 67056 configure_input="$ac_file. $configure_input"
67074 67057 { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
67075 67058 $as_echo "$as_me: creating $ac_file" >&6;}
67076 67059 fi
67077 67060 # Neutralize special characters interpreted by sed in replacement strings.
67078 67061 case $configure_input in #(
67079 67062 *\&* | *\|* | *\\* )
67080 67063 ac_sed_conf_input=`$as_echo "$configure_input" |
67081 67064 sed 's/[\\\\&|]/\\\\&/g'`;; #(
67082 67065 *) ac_sed_conf_input=$configure_input;;
67083 67066 esac
67084 67067
67085 67068 case $ac_tag in
67086 67069 *:-:* | *:-) cat >"$ac_tmp/stdin" \
67087 67070 || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
67088 67071 esac
67089 67072 ;;
67090 67073 esac
67091 67074
67092 67075 ac_dir=`$as_dirname -- "$ac_file" ||
67093 67076 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
67094 67077 X"$ac_file" : 'X\(//\)[^/]' \| \
67095 67078 X"$ac_file" : 'X\(//\)$' \| \
67096 67079 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
67097 67080 $as_echo X"$ac_file" |
67098 67081 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
67099 67082 s//\1/
67100 67083 q
67101 67084 }
67102 67085 /^X\(\/\/\)[^/].*/{
67103 67086 s//\1/
67104 67087 q
67105 67088 }
67106 67089 /^X\(\/\/\)$/{
67107 67090 s//\1/
67108 67091 q
67109 67092 }
67110 67093 /^X\(\/\).*/{
67111 67094 s//\1/
67112 67095 q
67113 67096 }
67114 67097 s/.*/./; q'`
67115 67098 as_dir="$ac_dir"; as_fn_mkdir_p
67116 67099 ac_builddir=.
67117 67100
67118 67101 case "$ac_dir" in
67119 67102 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
67120 67103 *)
67121 67104 ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
67122 67105 # A ".." for each directory in $ac_dir_suffix.
67123 67106 ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
67124 67107 case $ac_top_builddir_sub in
67125 67108 "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
67126 67109 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
67127 67110 esac ;;
67128 67111 esac
67129 67112 ac_abs_top_builddir=$ac_pwd
67130 67113 ac_abs_builddir=$ac_pwd$ac_dir_suffix
67131 67114 # for backward compatibility:
67132 67115 ac_top_builddir=$ac_top_build_prefix
67133 67116
67134 67117 case $srcdir in
67135 67118 .) # We are building in place.
67136 67119 ac_srcdir=.
67137 67120 ac_top_srcdir=$ac_top_builddir_sub
67138 67121 ac_abs_top_srcdir=$ac_pwd ;;
67139 67122 [\\/]* | ?:[\\/]* ) # Absolute name.
67140 67123 ac_srcdir=$srcdir$ac_dir_suffix;
67141 67124 ac_top_srcdir=$srcdir
67142 67125 ac_abs_top_srcdir=$srcdir ;;
67143 67126 *) # Relative name.
67144 67127 ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
67145 67128 ac_top_srcdir=$ac_top_build_prefix$srcdir
67146 67129 ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
67147 67130 esac
67148 67131 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
67149 67132
67150 67133
67151 67134 case $ac_mode in
67152 67135 :F)
67153 67136 #
67154 67137 # CONFIG_FILE
67155 67138 #
67156 67139
67157 67140 _ACEOF
67158 67141
67159 67142 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
67160 67143 # If the template does not know about datarootdir, expand it.
67161 67144 # FIXME: This hack should be removed a few years after 2.60.
67162 67145 ac_datarootdir_hack=; ac_datarootdir_seen=
67163 67146 ac_sed_dataroot='
67164 67147 /datarootdir/ {
67165 67148 p
67166 67149 q
67167 67150 }
67168 67151 /@datadir@/p
67169 67152 /@docdir@/p
67170 67153 /@infodir@/p
67171 67154 /@localedir@/p
67172 67155 /@mandir@/p'
67173 67156 case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
67174 67157 *datarootdir*) ac_datarootdir_seen=yes;;
67175 67158 *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
67176 67159 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
67177 67160 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
67178 67161 _ACEOF
67179 67162 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
67180 67163 ac_datarootdir_hack='
67181 67164 s&@datadir@&$datadir&g
67182 67165 s&@docdir@&$docdir&g
67183 67166 s&@infodir@&$infodir&g
67184 67167 s&@localedir@&$localedir&g
67185 67168 s&@mandir@&$mandir&g
67186 67169 s&\\\${datarootdir}&$datarootdir&g' ;;
67187 67170 esac
67188 67171 _ACEOF
67189 67172
67190 67173 # Neutralize VPATH when `$srcdir' = `.'.
67191 67174 # Shell code in configure.ac might set extrasub.
67192 67175 # FIXME: do we really want to maintain this feature?
67193 67176 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
67194 67177 ac_sed_extra="$ac_vpsub
67195 67178 $extrasub
67196 67179 _ACEOF
67197 67180 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
67198 67181 :t
67199 67182 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
67200 67183 s|@configure_input@|$ac_sed_conf_input|;t t
67201 67184 s&@top_builddir@&$ac_top_builddir_sub&;t t
67202 67185 s&@top_build_prefix@&$ac_top_build_prefix&;t t
67203 67186 s&@srcdir@&$ac_srcdir&;t t
67204 67187 s&@abs_srcdir@&$ac_abs_srcdir&;t t
67205 67188 s&@top_srcdir@&$ac_top_srcdir&;t t
67206 67189 s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
67207 67190 s&@builddir@&$ac_builddir&;t t
67208 67191 s&@abs_builddir@&$ac_abs_builddir&;t t
67209 67192 s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
67210 67193 $ac_datarootdir_hack
67211 67194 "
67212 67195 eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
67213 67196 >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
67214 67197
67215 67198 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
67216 67199 { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
67217 67200 { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \
67218 67201 "$ac_tmp/out"`; test -z "$ac_out"; } &&
67219 67202 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
67220 67203 which seems to be undefined. Please make sure it is defined" >&5
67221 67204 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
67222 67205 which seems to be undefined. Please make sure it is defined" >&2;}
67223 67206
67224 67207 rm -f "$ac_tmp/stdin"
67225 67208 case $ac_file in
67226 67209 -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
67227 67210 *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
67228 67211 esac \
67229 67212 || as_fn_error $? "could not create $ac_file" "$LINENO" 5
67230 67213 ;;
67231 67214
67232 67215
67233 67216
67234 67217 esac
67235 67218
67236 67219 done # for ac_tag
67237 67220
67238 67221
67239 67222 as_fn_exit 0
67240 67223 _ACEOF
67241 67224 ac_clean_files=$ac_clean_files_save
67242 67225
67243 67226 test $ac_write_fail = 0 ||
67244 67227 as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
67245 67228
67246 67229
67247 67230 # configure is writing to config.log, and then calls config.status.
67248 67231 # config.status does its own redirection, appending to config.log.
67249 67232 # Unfortunately, on DOS this fails, as config.log is still kept open
67250 67233 # by configure, so config.status won't be able to write to it; its
67251 67234 # output is simply discarded. So we exec the FD to /dev/null,
67252 67235 # effectively closing config.log, so it can be properly (re)opened and
67253 67236 # appended to by config.status. When coming back to configure, we
67254 67237 # need to make the FD available again.
67255 67238 if test "$no_create" != yes; then
67256 67239 ac_cs_success=:
67257 67240 ac_config_status_args=
67258 67241 test "$silent" = yes &&
67259 67242 ac_config_status_args="$ac_config_status_args --quiet"
67260 67243 exec 5>/dev/null
67261 67244 $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
67262 67245 exec 5>>config.log
67263 67246 # Use ||, not &&, to avoid exiting from the if with $? = 1, which
67264 67247 # would make configure fail if this is the last instruction.
67265 67248 $ac_cs_success || as_fn_exit 1
67266 67249 fi
67267 67250 if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
67268 67251 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
67269 67252 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
67270 67253 fi
67271 67254
67272 67255
67273 67256 # After AC_OUTPUT, we need to do final work
67274 67257
67275 67258
67276 67259 # Try to move config.log (generated by autoconf) to the configure-support directory.
67277 67260 if test -e ./config.log; then
67278 67261 $MV -f ./config.log "$CONFIGURESUPPORT_OUTPUTDIR/config.log" 2> /dev/null
67279 67262 fi
67280 67263
67281 67264 # Rotate our log file (configure.log)
67282 67265 if test -e "$OUTPUT_ROOT/configure.log.old"; then
67283 67266 $RM -f "$OUTPUT_ROOT/configure.log.old"
67284 67267 fi
67285 67268 if test -e "$OUTPUT_ROOT/configure.log"; then
67286 67269 $MV -f "$OUTPUT_ROOT/configure.log" "$OUTPUT_ROOT/configure.log.old" 2> /dev/null
67287 67270 fi
67288 67271
67289 67272 # Move configure.log from current directory to the build output root
67290 67273 if test -e ./configure.log; then
67291 67274 $MV -f ./configure.log "$OUTPUT_ROOT/configure.log" 2> /dev/null
67292 67275 fi
67293 67276
67294 67277 # Make the compare script executable
67295 67278 $CHMOD +x $OUTPUT_ROOT/compare.sh
67296 67279
67297 67280
67298 67281 # Finally output some useful information to the user
67299 67282
67300 67283 # Finally output some useful information to the user
67301 67284
67302 67285 printf "\n"
67303 67286 printf "====================================================\n"
67304 67287 if test "x$no_create" != "xyes"; then
67305 67288 if test "x$IS_RECONFIGURE" != "xyes"; then
67306 67289 printf "A new configuration has been successfully created in\n%s\n" "$OUTPUT_ROOT"
67307 67290 else
67308 67291 printf "The existing configuration has been successfully updated in\n%s\n" "$OUTPUT_ROOT"
67309 67292 fi
67310 67293 else
67311 67294 if test "x$IS_RECONFIGURE" != "xyes"; then
67312 67295 printf "A configuration has been successfully checked but not created\n"
67313 67296 else
67314 67297 printf "The existing configuration has been successfully checked in\n%s\n" "$OUTPUT_ROOT"
67315 67298 fi
67316 67299 fi
67317 67300 if test "x$CONFIGURE_COMMAND_LINE" != x; then
67318 67301 printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n"
67319 67302 else
67320 67303 printf "using default settings.\n"
67321 67304 fi
67322 67305
67323 67306 printf "\n"
67324 67307 printf "Configuration summary:\n"
67325 67308 printf "* Debug level: $DEBUG_LEVEL\n"
67326 67309 printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
67327 67310 printf "* JDK variant: $JDK_VARIANT\n"
67328 67311 printf "* JVM variants: $JVM_VARIANTS\n"
67329 67312 printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n"
67330 67313 printf "* Version string: $VERSION_STRING ($VERSION_SHORT)\n"
67331 67314
67332 67315 printf "\n"
67333 67316 printf "Tools summary:\n"
67334 67317 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
67335 67318 printf "* Environment: $WINDOWS_ENV_VENDOR version $WINDOWS_ENV_VERSION (root at $WINDOWS_ENV_ROOT_PATH)\n"
67336 67319 fi
67337 67320 printf "* Boot JDK: $BOOT_JDK_VERSION (at $BOOT_JDK)\n"
67338 67321 if test "x$TOOLCHAIN_VERSION" != "x"; then
67339 67322 print_version=" $TOOLCHAIN_VERSION"
67340 67323 fi
67341 67324 printf "* Toolchain: $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION$print_version)\n"
67342 67325 printf "* C Compiler: Version $CC_VERSION_NUMBER (at $CC)\n"
67343 67326 printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at $CXX)\n"
67344 67327
67345 67328 printf "\n"
67346 67329 printf "Build performance summary:\n"
67347 67330 printf "* Cores to use: $JOBS\n"
67348 67331 printf "* Memory limit: $MEMORY_SIZE MB\n"
67349 67332 if test "x$CCACHE_STATUS" != "x"; then
67350 67333 printf "* ccache status: $CCACHE_STATUS\n"
67351 67334 fi
67352 67335 printf "\n"
67353 67336
67354 67337 if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xtrue"; then
67355 67338 printf "NOTE: You have requested to build more than one version of the JVM, which\n"
67356 67339 printf "will result in longer build times.\n"
67357 67340 printf "\n"
67358 67341 fi
67359 67342
67360 67343 if test "x$FOUND_ALT_VARIABLES" != "x"; then
67361 67344 printf "WARNING: You have old-style ALT_ environment variables set.\n"
67362 67345 printf "These are not respected, and will be ignored. It is recommended\n"
67363 67346 printf "that you clean your environment. The following variables are set:\n"
67364 67347 printf "$FOUND_ALT_VARIABLES\n"
67365 67348 printf "\n"
67366 67349 fi
67367 67350
67368 67351 if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then
67369 67352 printf "WARNING: Your build output directory is not on a local disk.\n"
67370 67353 printf "This will severely degrade build performance!\n"
67371 67354 printf "It is recommended that you create an output directory on a local disk,\n"
67372 67355 printf "and run the configure script again from that directory.\n"
67373 67356 printf "\n"
67374 67357 fi
67375 67358
67376 67359 if test "x$IS_RECONFIGURE" = "xyes" && test "x$no_create" != "xyes"; then
67377 67360 printf "WARNING: The result of this configuration has overridden an older\n"
67378 67361 printf "configuration. You *should* run 'make clean' to make sure you get a\n"
67379 67362 printf "proper build. Failure to do so might result in strange build problems.\n"
67380 67363 printf "\n"
67381 67364 fi
67382 67365
67383 67366 if test "x$IS_RECONFIGURE" != "xyes" && test "x$no_create" = "xyes"; then
67384 67367 printf "WARNING: The result of this configuration was not saved.\n"
67385 67368 printf "You should run without '--no-create | -n' to create the configuration.\n"
67386 67369 printf "\n"
67387 67370 fi
67388 67371
67389 67372
67390 67373
67391 67374 # Locate config.log.
67392 67375 if test -e "$CONFIGURESUPPORT_OUTPUTDIR/config.log"; then
67393 67376 CONFIG_LOG_PATH="$CONFIGURESUPPORT_OUTPUTDIR"
67394 67377 elif test -e "./config.log"; then
67395 67378 CONFIG_LOG_PATH="."
67396 67379 fi
67397 67380
67398 67381 if test -e "$CONFIG_LOG_PATH/config.log"; then
67399 67382 $GREP '^configure:.*: WARNING:' "$CONFIG_LOG_PATH/config.log" > /dev/null 2>&1
67400 67383 if test $? -eq 0; then
67401 67384 printf "The following warnings were produced. Repeated here for convenience:\n"
67402 67385 # We must quote sed expression (using []) to stop m4 from eating the [].
67403 67386 $GREP '^configure:.*: WARNING:' "$CONFIG_LOG_PATH/config.log" | $SED -e 's/^configure:[0-9]*: //'
67404 67387 printf "\n"
67405 67388 fi
67406 67389 fi
67407 67390
|
↓ open down ↓ |
10471 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX