1 #!/bin/bash
2 #
3 # ##########################################################
4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
5 # ##########################################################
6 #
7 #! /bin/sh
8 # Guess values for system-dependent variables and create Makefiles.
9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
10 #
11 # Report bugs to <build-dev@openjdk.java.net>.
12 #
13 #
14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
15 #
16 #
17 # This configure script is free software; the Free Software Foundation
18 # gives unlimited permission to copy, distribute and modify it.
19 ## -------------------- ##
20 ## M4sh Initialization. ##
21 ## -------------------- ##
22
23 # Be more Bourne compatible
24 DUALCASE=1; export DUALCASE # for MKS sh
25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
26 emulate sh
27 NULLCMD=:
28 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
29 # is contrary to our usage. Disable this feature.
30 alias -g '${1+"$@"}'='"$@"'
31 setopt NO_GLOB_SUBST
32 else
33 case `(set -o) 2>/dev/null` in #(
34 *posix*) :
35 set -o posix ;; #(
36 *) :
37 ;;
38 esac
39 fi
40
41
42 as_nl='
43 '
44 export as_nl
45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
49 # Prefer a ksh shell builtin over an external printf program on Solaris,
50 # but without wasting forks for bash or zsh.
51 if test -z "$BASH_VERSION$ZSH_VERSION" \
52 && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
53 as_echo='print -r --'
54 as_echo_n='print -rn --'
55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
56 as_echo='printf %s\n'
57 as_echo_n='printf %s'
58 else
59 if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
60 as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
61 as_echo_n='/usr/ucb/echo -n'
62 else
63 as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
64 as_echo_n_body='eval
65 arg=$1;
66 case $arg in #(
67 *"$as_nl"*)
68 expr "X$arg" : "X\\(.*\\)$as_nl";
69 arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
70 esac;
71 expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
72 '
73 export as_echo_n_body
74 as_echo_n='sh -c $as_echo_n_body as_echo'
75 fi
76 export as_echo_body
77 as_echo='sh -c $as_echo_body as_echo'
78 fi
79
80 # The user is always right.
81 if test "${PATH_SEPARATOR+set}" != set; then
82 PATH_SEPARATOR=:
83 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
84 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
85 PATH_SEPARATOR=';'
86 }
87 fi
88
89
90 # IFS
91 # We need space, tab and new line, in precisely that order. Quoting is
92 # there to prevent editors from complaining about space-tab.
93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
94 # splitting by setting IFS to empty value.)
95 IFS=" "" $as_nl"
96
97 # Find who we are. Look in the path if we contain no directory separator.
98 as_myself=
99 case $0 in #((
100 *[\\/]* ) as_myself=$0 ;;
101 *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
102 for as_dir in $PATH
103 do
104 IFS=$as_save_IFS
105 test -z "$as_dir" && as_dir=.
106 test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
107 done
108 IFS=$as_save_IFS
109
110 ;;
111 esac
112 # We did not find ourselves, most probably we were run as `sh COMMAND'
113 # in which case we are not to be found in the path.
114 if test "x$as_myself" = x; then
115 as_myself=$0
116 fi
117 if test ! -f "$as_myself"; then
118 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
119 exit 1
120 fi
121
122 # Unset variables that we do not need and which cause bugs (e.g. in
123 # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
124 # suppresses any "Segmentation fault" message there. '((' could
125 # trigger a bug in pdksh 5.2.14.
126 for as_var in BASH_ENV ENV MAIL MAILPATH
127 do eval test x\${$as_var+set} = xset \
128 && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
129 done
130 PS1='$ '
131 PS2='> '
132 PS4='+ '
133
134 # NLS nuisances.
135 LC_ALL=C
136 export LC_ALL
137 LANGUAGE=C
138 export LANGUAGE
139
140 # CDPATH.
141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
142
143 # Use a proper internal environment variable to ensure we don't fall
144 # into an infinite loop, continuously re-executing ourselves.
145 if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
146 _as_can_reexec=no; export _as_can_reexec;
147 # We cannot yet assume a decent shell, so we have to provide a
148 # neutralization value for shells without unset; and this also
149 # works around shells that cannot unset nonexistent variables.
150 # Preserve -v and -x to the replacement shell.
151 BASH_ENV=/dev/null
152 ENV=/dev/null
153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
154 case $- in # ((((
155 *v*x* | *x*v* ) as_opts=-vx ;;
156 *v* ) as_opts=-v ;;
157 *x* ) as_opts=-x ;;
158 * ) as_opts= ;;
159 esac
160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
161 # Admittedly, this is quite paranoid, since all the known shells bail
162 # out after a failed `exec'.
163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
164 as_fn_exit 255
165 fi
166 # We don't want this to propagate to other subprocesses.
167 { _as_can_reexec=; unset _as_can_reexec;}
168 if test "x$CONFIG_SHELL" = x; then
169 as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
170 emulate sh
171 NULLCMD=:
172 # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
173 # is contrary to our usage. Disable this feature.
174 alias -g '\${1+\"\$@\"}'='\"\$@\"'
175 setopt NO_GLOB_SUBST
176 else
177 case \`(set -o) 2>/dev/null\` in #(
178 *posix*) :
179 set -o posix ;; #(
180 *) :
181 ;;
182 esac
183 fi
184 "
185 as_required="as_fn_return () { (exit \$1); }
186 as_fn_success () { as_fn_return 0; }
187 as_fn_failure () { as_fn_return 1; }
188 as_fn_ret_success () { return 0; }
189 as_fn_ret_failure () { return 1; }
190
191 exitcode=0
192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
197
198 else
199 exitcode=1; echo positional parameters were not saved.
200 fi
201 test x\$exitcode = x0 || exit 1
202 test -x / || exit 1"
203 as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
204 as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
205 eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
206 test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
207 test \$(( 1 + 1 )) = 2 || exit 1"
208 if (eval "$as_required") 2>/dev/null; then :
209 as_have_required=yes
210 else
211 as_have_required=no
212 fi
213 if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
214
215 else
216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
217 as_found=false
218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
219 do
220 IFS=$as_save_IFS
221 test -z "$as_dir" && as_dir=.
222 as_found=:
223 case $as_dir in #(
224 /*)
225 for as_base in sh bash ksh sh5; do
226 # Try only shells that exist, to save several forks.
227 as_shell=$as_dir/$as_base
228 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
229 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
230 CONFIG_SHELL=$as_shell as_have_required=yes
231 if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
232 break 2
233 fi
234 fi
235 done;;
236 esac
237 as_found=false
238 done
239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
240 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
241 CONFIG_SHELL=$SHELL as_have_required=yes
242 fi; }
243 IFS=$as_save_IFS
244
245
246 if test "x$CONFIG_SHELL" != x; then :
247 export CONFIG_SHELL
248 # We cannot yet assume a decent shell, so we have to provide a
249 # neutralization value for shells without unset; and this also
250 # works around shells that cannot unset nonexistent variables.
251 # Preserve -v and -x to the replacement shell.
252 BASH_ENV=/dev/null
253 ENV=/dev/null
254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
255 case $- in # ((((
256 *v*x* | *x*v* ) as_opts=-vx ;;
257 *v* ) as_opts=-v ;;
258 *x* ) as_opts=-x ;;
259 * ) as_opts= ;;
260 esac
261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
262 # Admittedly, this is quite paranoid, since all the known shells bail
263 # out after a failed `exec'.
264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
265 exit 255
266 fi
267
268 if test x$as_have_required = xno; then :
269 $as_echo "$0: This script requires a shell more modern than all"
270 $as_echo "$0: the shells that I found on your system."
271 if test x${ZSH_VERSION+set} = xset ; then
272 $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
273 $as_echo "$0: be upgraded to zsh 4.3.4 or later."
274 else
275 $as_echo "$0: Please tell bug-autoconf@gnu.org and
276 $0: build-dev@openjdk.java.net about your system, including
277 $0: any error possibly output before this message. Then
278 $0: install a modern shell, or manually run the script
279 $0: under such a shell if you do have one."
280 fi
281 exit 1
282 fi
283 fi
284 fi
285 SHELL=${CONFIG_SHELL-/bin/sh}
286 export SHELL
287 # Unset more variables known to interfere with behavior of common tools.
288 CLICOLOR_FORCE= GREP_OPTIONS=
289 unset CLICOLOR_FORCE GREP_OPTIONS
290
291 ## --------------------- ##
292 ## M4sh Shell Functions. ##
293 ## --------------------- ##
294 # as_fn_unset VAR
295 # ---------------
296 # Portably unset VAR.
297 as_fn_unset ()
298 {
299 { eval $1=; unset $1;}
300 }
301 as_unset=as_fn_unset
302
303 # as_fn_set_status STATUS
304 # -----------------------
305 # Set $? to STATUS, without forking.
306 as_fn_set_status ()
307 {
308 return $1
309 } # as_fn_set_status
310
311 # as_fn_exit STATUS
312 # -----------------
313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
314 as_fn_exit ()
315 {
316 set +e
317 as_fn_set_status $1
318 exit $1
319 } # as_fn_exit
320
321 # as_fn_mkdir_p
322 # -------------
323 # Create "$as_dir" as a directory, including parents if necessary.
324 as_fn_mkdir_p ()
325 {
326
327 case $as_dir in #(
328 -*) as_dir=./$as_dir;;
329 esac
330 test -d "$as_dir" || eval $as_mkdir_p || {
331 as_dirs=
332 while :; do
333 case $as_dir in #(
334 *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
335 *) as_qdir=$as_dir;;
336 esac
337 as_dirs="'$as_qdir' $as_dirs"
338 as_dir=`$as_dirname -- "$as_dir" ||
339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
340 X"$as_dir" : 'X\(//\)[^/]' \| \
341 X"$as_dir" : 'X\(//\)$' \| \
342 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
343 $as_echo X"$as_dir" |
344 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
345 s//\1/
346 q
347 }
348 /^X\(\/\/\)[^/].*/{
349 s//\1/
350 q
351 }
352 /^X\(\/\/\)$/{
353 s//\1/
354 q
355 }
356 /^X\(\/\).*/{
357 s//\1/
358 q
359 }
360 s/.*/./; q'`
361 test -d "$as_dir" && break
362 done
363 test -z "$as_dirs" || eval "mkdir $as_dirs"
364 } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
365
366
367 } # as_fn_mkdir_p
368
369 # as_fn_executable_p FILE
370 # -----------------------
371 # Test if FILE is an executable regular file.
372 as_fn_executable_p ()
373 {
374 test -f "$1" && test -x "$1"
375 } # as_fn_executable_p
376 # as_fn_append VAR VALUE
377 # ----------------------
378 # Append the text in VALUE to the end of the definition contained in VAR. Take
379 # advantage of any shell optimizations that allow amortized linear growth over
380 # repeated appends, instead of the typical quadratic growth present in naive
381 # implementations.
382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
383 eval 'as_fn_append ()
384 {
385 eval $1+=\$2
386 }'
387 else
388 as_fn_append ()
389 {
390 eval $1=\$$1\$2
391 }
392 fi # as_fn_append
393
394 # as_fn_arith ARG...
395 # ------------------
396 # Perform arithmetic evaluation on the ARGs, and store the result in the
397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
398 # must be portable across $(()) and expr.
399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
400 eval 'as_fn_arith ()
401 {
402 as_val=$(( $* ))
403 }'
404 else
405 as_fn_arith ()
406 {
407 as_val=`expr "$@" || test $? -eq 1`
408 }
409 fi # as_fn_arith
410
411
412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
413 # ----------------------------------------
414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
416 # script with STATUS, using 1 if that was 0.
417 as_fn_error ()
418 {
419 as_status=$1; test $as_status -eq 0 && as_status=1
420 if test "$4"; then
421 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
422 $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
423 fi
424 $as_echo "$as_me: error: $2" >&2
425 as_fn_exit $as_status
426 } # as_fn_error
427
428 if expr a : '\(a\)' >/dev/null 2>&1 &&
429 test "X`expr 00001 : '.*\(...\)'`" = X001; then
430 as_expr=expr
431 else
432 as_expr=false
433 fi
434
435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
436 as_basename=basename
437 else
438 as_basename=false
439 fi
440
441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
442 as_dirname=dirname
443 else
444 as_dirname=false
445 fi
446
447 as_me=`$as_basename -- "$0" ||
448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
449 X"$0" : 'X\(//\)$' \| \
450 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
451 $as_echo X/"$0" |
452 sed '/^.*\/\([^/][^/]*\)\/*$/{
453 s//\1/
454 q
455 }
456 /^X\/\(\/\/\)$/{
457 s//\1/
458 q
459 }
460 /^X\/\(\/\).*/{
461 s//\1/
462 q
463 }
464 s/.*/./; q'`
465
466 # Avoid depending upon Character Ranges.
467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
470 as_cr_digits='0123456789'
471 as_cr_alnum=$as_cr_Letters$as_cr_digits
472
473
474 as_lineno_1=$LINENO as_lineno_1a=$LINENO
475 as_lineno_2=$LINENO as_lineno_2a=$LINENO
476 eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
477 test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
478 # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
479 sed -n '
480 p
481 /[$]LINENO/=
482 ' <$as_myself |
483 sed '
484 s/[$]LINENO.*/&-/
485 t lineno
486 b
487 :lineno
488 N
489 :loop
490 s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
491 t loop
492 s/-\n.*//
493 ' >$as_me.lineno &&
494 chmod +x "$as_me.lineno" ||
495 { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
496
497 # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
498 # already done that, so ensure we don't try to do so again and fall
499 # in an infinite loop. This has already happened in practice.
500 _as_can_reexec=no; export _as_can_reexec
501 # Don't try to exec as it changes $[0], causing all sort of problems
502 # (the dirname of $[0] is not the place where we might find the
503 # original and so on. Autoconf is especially sensitive to this).
504 . "./$as_me.lineno"
505 # Exit status is that of the last command.
506 exit
507 }
508
509 ECHO_C= ECHO_N= ECHO_T=
510 case `echo -n x` in #(((((
511 -n*)
512 case `echo 'xy\c'` in
513 *c*) ECHO_T=' ';; # ECHO_T is single tab character.
514 xy) ECHO_C='\c';;
515 *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
516 ECHO_T=' ';;
517 esac;;
518 *)
519 ECHO_N='-n';;
520 esac
521
522 rm -f conf$$ conf$$.exe conf$$.file
523 if test -d conf$$.dir; then
524 rm -f conf$$.dir/conf$$.file
525 else
526 rm -f conf$$.dir
527 mkdir conf$$.dir 2>/dev/null
528 fi
529 if (echo >conf$$.file) 2>/dev/null; then
530 if ln -s conf$$.file conf$$ 2>/dev/null; then
531 as_ln_s='ln -s'
532 # ... but there are two gotchas:
533 # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
534 # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
535 # In both cases, we have to default to `cp -pR'.
536 ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
537 as_ln_s='cp -pR'
538 elif ln conf$$.file conf$$ 2>/dev/null; then
539 as_ln_s=ln
540 else
541 as_ln_s='cp -pR'
542 fi
543 else
544 as_ln_s='cp -pR'
545 fi
546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
547 rmdir conf$$.dir 2>/dev/null
548
549 if mkdir -p . 2>/dev/null; then
550 as_mkdir_p='mkdir -p "$as_dir"'
551 else
552 test -d ./-p && rmdir ./-p
553 as_mkdir_p=false
554 fi
555
556 as_test_x='test -x'
557 as_executable_p=as_fn_executable_p
558
559 # Sed expression to map a string onto a valid CPP name.
560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
561
562 # Sed expression to map a string onto a valid variable name.
563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
564
565
566 test -n "$DJDIR" || exec 7<&0 </dev/null
567 exec 6>&1
568
569 # Name of the host.
570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
571 # so uname gets run too.
572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
573
574 #
575 # Initializations.
576 #
577 ac_default_prefix=/usr/local
578 ac_clean_files=
579 ac_config_libobj_dir=.
580 LIBOBJS=
581 cross_compiling=no
582 subdirs=
583 MFLAGS=
584 MAKEFLAGS=
585
586 # Identity of this package.
587 PACKAGE_NAME='OpenJDK'
588 PACKAGE_TARNAME='openjdk'
589 PACKAGE_VERSION='jdk9'
590 PACKAGE_STRING='OpenJDK jdk9'
591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
592 PACKAGE_URL='http://openjdk.java.net'
593
594 # Factoring default headers for most tests.
595 ac_includes_default="\
596 #include <stdio.h>
597 #ifdef HAVE_SYS_TYPES_H
598 # include <sys/types.h>
599 #endif
600 #ifdef HAVE_SYS_STAT_H
601 # include <sys/stat.h>
602 #endif
603 #ifdef STDC_HEADERS
604 # include <stdlib.h>
605 # include <stddef.h>
606 #else
607 # ifdef HAVE_STDLIB_H
608 # include <stdlib.h>
609 # endif
610 #endif
611 #ifdef HAVE_STRING_H
612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
613 # include <memory.h>
614 # endif
615 # include <string.h>
616 #endif
617 #ifdef HAVE_STRINGS_H
618 # include <strings.h>
619 #endif
620 #ifdef HAVE_INTTYPES_H
621 # include <inttypes.h>
622 #endif
623 #ifdef HAVE_STDINT_H
624 # include <stdint.h>
625 #endif
626 #ifdef HAVE_UNISTD_H
627 # include <unistd.h>
628 #endif"
629
630 ac_subst_vars='LTLIBOBJS
631 LIBOBJS
632 CFLAGS_CCACHE
633 CCACHE
634 USE_PRECOMPILED_HEADER
635 SJAVAC_SERVER_DIR
636 ENABLE_SJAVAC
637 SJAVAC_SERVER_JAVA_FLAGS
638 SJAVAC_SERVER_JAVA
639 JAVA_TOOL_FLAGS_SMALL
640 JAVA_FLAGS_SMALL
641 JAVA_FLAGS_BIG
642 JAVA_FLAGS
643 JOBS
644 MEMORY_SIZE
645 NUM_CORES
646 ENABLE_INTREE_EC
647 SALIB_NAME
648 HOTSPOT_MAKE_ARGS
649 MSVCP_DLL
650 MSVCR_DLL
651 LIBCXX
652 LLVM_LIBS
653 LLVM_LDFLAGS
654 LLVM_CFLAGS
655 LLVM_CONFIG
656 LIBFFI_LIBS
657 LIBFFI_CFLAGS
658 STATIC_CXX_SETTING
659 LIBDL
660 LIBM
661 LIBZIP_CAN_USE_MMAP
662 USE_EXTERNAL_LIBZ
663 USE_EXTERNAL_LIBPNG
664 PNG_LIBS
665 PNG_CFLAGS
666 USE_EXTERNAL_LCMS
667 LCMS_LIBS
668 LCMS_CFLAGS
669 USE_EXTERNAL_LIBGIF
670 USE_EXTERNAL_LIBJPEG
671 ALSA_LIBS
672 ALSA_CFLAGS
673 FREETYPE_BUNDLE_LIB_PATH
674 FREETYPE_LIBS
675 FREETYPE_CFLAGS
676 CUPS_CFLAGS
677 X_EXTRA_LIBS
678 X_LIBS
679 X_PRE_LIBS
680 X_CFLAGS
681 XMKMF
682 FIXPATH
683 ZIP_DEBUGINFO_FILES
684 ENABLE_DEBUG_SYMBOLS
685 CFLAGS_WARNINGS_ARE_ERRORS
686 DISABLE_WARNING_PREFIX
687 COMPILER_SUPPORTS_TARGET_BITS_FLAG
688 ZERO_ARCHFLAG
689 LDFLAGS_CXX_JDK
690 LDFLAGS_JDKEXE_SUFFIX
691 LDFLAGS_JDKLIB_SUFFIX
692 LDFLAGS_JDKEXE
693 LDFLAGS_JDKLIB
694 CXXFLAGS_JDKEXE
695 CXXFLAGS_JDKLIB
696 CFLAGS_JDKEXE
697 CFLAGS_JDKLIB
698 MACOSX_VERSION_MIN
699 LEGACY_EXTRA_LDFLAGS
700 LEGACY_EXTRA_CXXFLAGS
701 LEGACY_EXTRA_CFLAGS
702 CXX_O_FLAG_NONE
703 CXX_O_FLAG_DEBUG
704 CXX_O_FLAG_NORM
705 CXX_O_FLAG_HI
706 CXX_O_FLAG_HIGHEST
707 C_O_FLAG_NONE
708 C_O_FLAG_DEBUG
709 C_O_FLAG_NORM
710 C_O_FLAG_HI
711 C_O_FLAG_HIGHEST
712 CXXFLAGS_DEBUG_OPTIONS
713 CFLAGS_DEBUG_OPTIONS
714 CXXFLAGS_DEBUG_SYMBOLS
715 CFLAGS_DEBUG_SYMBOLS
716 CXX_FLAG_DEPS
717 C_FLAG_DEPS
718 SET_SHARED_LIBRARY_MAPFILE
719 SET_SHARED_LIBRARY_NAME
720 SET_SHARED_LIBRARY_ORIGIN
721 SET_EXECUTABLE_ORIGIN
722 SHARED_LIBRARY_FLAGS
723 CXX_FLAG_REORDER
724 C_FLAG_REORDER
725 SYSROOT_LDFLAGS
726 SYSROOT_CFLAGS
727 RC_FLAGS
728 AR_OUT_OPTION
729 LD_OUT_OPTION
730 EXE_OUT_OPTION
731 CC_OUT_OPTION
732 POST_MCS_CMD
733 POST_STRIP_CMD
734 ARFLAGS
735 COMPILER_TARGET_BITS_FLAG
736 JT_HOME
737 JTREGEXE
738 USING_BROKEN_SUSE_LD
739 PACKAGE_PATH
740 LDEXECXX
741 LDEXE
742 USE_CLANG
743 HOTSPOT_LD
744 HOTSPOT_CXX
745 HOTSPOT_RC
746 HOTSPOT_MT
747 BUILD_LD
748 BUILD_CXX
749 BUILD_CC
750 ac_ct_OBJDUMP
751 OBJDUMP
752 ac_ct_OBJCOPY
753 OBJCOPY
754 ac_ct_NM
755 ac_ct_STRIP
756 MCS
757 GNM
758 NM
759 STRIP
760 MSBUILD
761 DUMPBIN
762 RC
763 MT
764 LIPO
765 ac_ct_AR
766 AR
767 AS
768 LDCXX
769 LD
770 CXXCPP
771 CPP
772 ac_ct_CXX
773 CXXFLAGS
774 CXX
775 ac_ct_PROPER_COMPILER_CXX
776 PROPER_COMPILER_CXX
777 TOOLCHAIN_PATH_CXX
778 POTENTIAL_CXX
779 OBJEXT
780 EXEEXT
781 ac_ct_CC
782 CPPFLAGS
783 LDFLAGS
784 CFLAGS
785 CC
786 ac_ct_PROPER_COMPILER_CC
787 PROPER_COMPILER_CC
788 TOOLCHAIN_PATH_CC
789 POTENTIAL_CC
790 VS_LIB
791 VS_INCLUDE
792 VS_PATH
793 CYGWIN_LINK
794 EXE_SUFFIX
795 OBJ_SUFFIX
796 STATIC_LIBRARY
797 SHARED_LIBRARY
798 STATIC_LIBRARY_SUFFIX
799 SHARED_LIBRARY_SUFFIX
800 LIBRARY_PREFIX
801 TOOLCHAIN_TYPE
802 BUILD_HOTSPOT
803 HOTSPOT_DIST
804 BUILD_OUTPUT
805 OVERRIDE_SRC_ROOT
806 ADD_SRC_ROOT
807 JDK_TOPDIR
808 NASHORN_TOPDIR
809 HOTSPOT_TOPDIR
810 JAXWS_TOPDIR
811 JAXP_TOPDIR
812 CORBA_TOPDIR
813 LANGTOOLS_TOPDIR
814 JAVAC_FLAGS
815 BOOT_JDK_SOURCETARGET
816 JARSIGNER
817 NATIVE2ASCII
818 JAR
819 JAVAH
820 JAVAC
821 JAVA
822 BOOT_JDK
823 JAVA_CHECK
824 JAVAC_CHECK
825 COOKED_BUILD_NUMBER
826 JDK_VERSION
827 COPYRIGHT_YEAR
828 MACOSX_BUNDLE_ID_BASE
829 MACOSX_BUNDLE_NAME_BASE
830 COMPANY_NAME
831 JDK_RC_PLATFORM_NAME
832 PRODUCT_SUFFIX
833 PRODUCT_NAME
834 LAUNCHER_NAME
835 MILESTONE
836 JDK_BUILD_NUMBER
837 JDK_UPDATE_VERSION
838 JDK_MICRO_VERSION
839 JDK_MINOR_VERSION
840 JDK_MAJOR_VERSION
841 USER_RELEASE_SUFFIX
842 COMPRESS_JARS
843 RMICONNECTOR_IIOP
844 UNLIMITED_CRYPTO
845 CACERTS_FILE
846 TEST_IN_BUILD
847 BUILD_HEADLESS
848 SUPPORT_HEADFUL
849 SUPPORT_HEADLESS
850 BDEPS_FTP
851 BDEPS_UNZIP
852 OS_VERSION_MICRO
853 OS_VERSION_MINOR
854 OS_VERSION_MAJOR
855 PKG_CONFIG
856 BASH_ARGS
857 CODESIGN
858 XATTR
859 DSYMUTIL
860 IS_GNU_TIME
861 TIME
862 STAT
863 HG
864 READELF
865 OTOOL
866 LDD
867 ZIP
868 UNZIP
869 FIND_DELETE
870 OUTPUT_SYNC
871 OUTPUT_SYNC_SUPPORTED
872 MAKE
873 CHECK_TOOLSDIR_MAKE
874 CHECK_TOOLSDIR_GMAKE
875 CHECK_MAKE
876 CHECK_GMAKE
877 PKGHANDLER
878 OUTPUT_ROOT
879 CONF_NAME
880 SPEC
881 SDKROOT
882 XCODEBUILD
883 BUILD_VARIANT_RELEASE
884 DEBUG_CLASSFILES
885 FASTDEBUG
886 VARIANT
887 DEBUG_LEVEL
888 MACOSX_UNIVERSAL
889 INCLUDE_SA
890 JVM_VARIANT_CORE
891 JVM_VARIANT_ZEROSHARK
892 JVM_VARIANT_ZERO
893 JVM_VARIANT_KERNEL
894 JVM_VARIANT_MINIMAL1
895 JVM_VARIANT_CLIENT
896 JVM_VARIANT_SERVER
897 JVM_VARIANTS
898 JVM_INTERPRETER
899 JDK_VARIANT
900 SET_OPENJDK
901 BUILD_LOG_WRAPPER
902 BUILD_LOG_PREVIOUS
903 BUILD_LOG
904 TOPDIR
905 PATH_SEP
906 ZERO_ARCHDEF
907 DEFINE_CROSS_COMPILE_ARCH
908 LP64
909 OPENJDK_TARGET_OS_EXPORT_DIR
910 OPENJDK_TARGET_CPU_JLI_CFLAGS
911 OPENJDK_TARGET_CPU_OSARCH
912 OPENJDK_TARGET_CPU_ISADIR
913 OPENJDK_TARGET_CPU_LIBDIR
914 OPENJDK_TARGET_CPU_LEGACY_LIB
915 OPENJDK_TARGET_CPU_LEGACY
916 REQUIRED_OS_VERSION
917 REQUIRED_OS_NAME
918 COMPILE_TYPE
919 OPENJDK_TARGET_CPU_ENDIAN
920 OPENJDK_TARGET_CPU_BITS
921 OPENJDK_TARGET_CPU_ARCH
922 OPENJDK_TARGET_CPU
923 OPENJDK_TARGET_OS_ENV
924 OPENJDK_TARGET_OS_TYPE
925 OPENJDK_TARGET_OS
926 OPENJDK_BUILD_CPU_ENDIAN
927 OPENJDK_BUILD_CPU_BITS
928 OPENJDK_BUILD_CPU_ARCH
929 OPENJDK_BUILD_CPU
930 OPENJDK_BUILD_OS_ENV
931 OPENJDK_BUILD_OS_TYPE
932 OPENJDK_BUILD_OS
933 OPENJDK_BUILD_AUTOCONF_NAME
934 OPENJDK_TARGET_AUTOCONF_NAME
935 target_os
936 target_vendor
937 target_cpu
938 target
939 host_os
940 host_vendor
941 host_cpu
942 host
943 build_os
944 build_vendor
945 build_cpu
946 build
947 CPIO
948 SETFILE
949 DF
950 READLINK
951 CYGPATH
952 SED
953 FGREP
954 EGREP
955 GREP
956 AWK
957 XARGS
958 WHICH
959 WC
960 UNIQ
961 UNAME
962 TR
963 TOUCH
964 TEE
965 TAR
966 TAIL
967 SORT
968 SH
969 RM
970 PRINTF
971 NAWK
972 MV
973 MKTEMP
974 MKDIR
975 LS
976 LN
977 HEAD
978 FIND
979 FILE
980 EXPR
981 ECHO
982 DIRNAME
983 DIFF
984 DATE
985 CUT
986 CP
987 COMM
988 CMP
989 CHMOD
990 CAT
991 BASH
992 BASENAME
993 DATE_WHEN_CONFIGURED
994 ORIGINAL_PATH
995 CONFIGURE_COMMAND_LINE
996 target_alias
997 host_alias
998 build_alias
999 LIBS
1000 ECHO_T
1001 ECHO_N
1002 ECHO_C
1003 DEFS
1004 mandir
1005 localedir
1006 libdir
1007 psdir
1008 pdfdir
1009 dvidir
1010 htmldir
1011 infodir
1012 docdir
1013 oldincludedir
1014 includedir
1015 localstatedir
1016 sharedstatedir
1017 sysconfdir
1018 datadir
1019 datarootdir
1020 libexecdir
1021 sbindir
1022 bindir
1023 program_transform_name
1024 prefix
1025 exec_prefix
1026 PACKAGE_URL
1027 PACKAGE_BUGREPORT
1028 PACKAGE_STRING
1029 PACKAGE_VERSION
1030 PACKAGE_TARNAME
1031 PACKAGE_NAME
1032 PATH_SEPARATOR
1033 SHELL'
1034 ac_subst_files=''
1035 ac_user_opts='
1036 enable_option_checking
1037 with_target_bits
1038 enable_openjdk_only
1039 with_custom_make_dir
1040 with_jdk_variant
1041 with_jvm_interpreter
1042 with_jvm_variants
1043 enable_debug
1044 with_debug_level
1045 with_devkit
1046 with_sys_root
1047 with_sysroot
1048 with_tools_dir
1049 with_toolchain_path
1050 with_extra_path
1051 with_sdk_name
1052 with_conf_name
1053 with_output_sync
1054 with_builddeps_conf
1055 with_builddeps_server
1056 with_builddeps_dir
1057 with_builddeps_group
1058 enable_headful
1059 enable_hotspot_test_in_build
1060 with_cacerts_file
1061 enable_unlimited_crypto
1062 enable_rmiconnector_iiop
1063 with_milestone
1064 with_update_version
1065 with_user_release_suffix
1066 with_build_number
1067 with_copyright_year
1068 with_boot_jdk
1069 with_add_source_root
1070 with_override_source_root
1071 with_adds_and_overrides
1072 with_override_langtools
1073 with_override_corba
1074 with_override_jaxp
1075 with_override_jaxws
1076 with_override_hotspot
1077 with_override_nashorn
1078 with_override_jdk
1079 with_import_hotspot
1080 with_toolchain_type
1081 with_toolchain_version
1082 with_jtreg
1083 with_extra_cflags
1084 with_extra_cxxflags
1085 with_extra_ldflags
1086 enable_debug_symbols
1087 enable_zip_debug_info
1088 with_x
1089 with_cups
1090 with_cups_include
1091 with_freetype
1092 with_freetype_include
1093 with_freetype_lib
1094 with_freetype_src
1095 enable_freetype_bundling
1096 with_alsa
1097 with_alsa_include
1098 with_alsa_lib
1099 with_libjpeg
1100 with_giflib
1101 with_lcms
1102 with_libpng
1103 with_zlib
1104 with_stdc__lib
1105 with_msvcr_dll
1106 with_msvcp_dll
1107 with_dxsdk
1108 with_dxsdk_lib
1109 with_dxsdk_include
1110 with_num_cores
1111 with_memory_size
1112 with_jobs
1113 with_boot_jdk_jvmargs
1114 with_sjavac_server_java
1115 enable_sjavac
1116 enable_precompiled_headers
1117 enable_ccache
1118 with_ccache_dir
1119 '
1120 ac_precious_vars='build_alias
1121 host_alias
1122 target_alias
1123 BASENAME
1124 BASH
1125 CAT
1126 CHMOD
1127 CMP
1128 COMM
1129 CP
1130 CUT
1131 DATE
1132 DIFF
1133 DIRNAME
1134 ECHO
1135 EXPR
1136 FILE
1137 FIND
1138 HEAD
1139 LN
1140 LS
1141 MKDIR
1142 MKTEMP
1143 MV
1144 NAWK
1145 PRINTF
1146 RM
1147 SH
1148 SORT
1149 TAIL
1150 TAR
1151 TEE
1152 TOUCH
1153 TR
1154 UNAME
1155 UNIQ
1156 WC
1157 WHICH
1158 XARGS
1159 AWK
1160 GREP
1161 EGREP
1162 FGREP
1163 SED
1164 CYGPATH
1165 READLINK
1166 DF
1167 SETFILE
1168 CPIO
1169 UNZIP
1170 ZIP
1171 LDD
1172 OTOOL
1173 READELF
1174 HG
1175 STAT
1176 TIME
1177 DSYMUTIL
1178 XATTR
1179 CODESIGN
1180 PKG_CONFIG
1181 JAVA
1182 JAVAC
1183 JAVAH
1184 JAR
1185 NATIVE2ASCII
1186 JARSIGNER
1187 CC
1188 CFLAGS
1189 LDFLAGS
1190 LIBS
1191 CPPFLAGS
1192 CXX
1193 CXXFLAGS
1194 CCC
1195 CPP
1196 CXXCPP
1197 AS
1198 AR
1199 LIPO
1200 STRIP
1201 NM
1202 GNM
1203 MCS
1204 OBJCOPY
1205 OBJDUMP
1206 BUILD_CC
1207 BUILD_CXX
1208 BUILD_LD
1209 JTREGEXE
1210 XMKMF
1211 FREETYPE_CFLAGS
1212 FREETYPE_LIBS
1213 ALSA_CFLAGS
1214 ALSA_LIBS
1215 LCMS_CFLAGS
1216 LCMS_LIBS
1217 PNG_CFLAGS
1218 PNG_LIBS
1219 LIBFFI_CFLAGS
1220 LIBFFI_LIBS
1221 CCACHE'
1222
1223
1224 # Initialize some variables set by options.
1225 ac_init_help=
1226 ac_init_version=false
1227 ac_unrecognized_opts=
1228 ac_unrecognized_sep=
1229 # The variables have the same names as the options, with
1230 # dashes changed to underlines.
1231 cache_file=/dev/null
1232 exec_prefix=NONE
1233 no_create=
1234 no_recursion=
1235 prefix=NONE
1236 program_prefix=NONE
1237 program_suffix=NONE
1238 program_transform_name=s,x,x,
1239 silent=
1240 site=
1241 srcdir=
1242 verbose=
1243 x_includes=NONE
1244 x_libraries=NONE
1245
1246 # Installation directory options.
1247 # These are left unexpanded so users can "make install exec_prefix=/foo"
1248 # and all the variables that are supposed to be based on exec_prefix
1249 # by default will actually change.
1250 # Use braces instead of parens because sh, perl, etc. also accept them.
1251 # (The list follows the same order as the GNU Coding Standards.)
1252 bindir='${exec_prefix}/bin'
1253 sbindir='${exec_prefix}/sbin'
1254 libexecdir='${exec_prefix}/libexec'
1255 datarootdir='${prefix}/share'
1256 datadir='${datarootdir}'
1257 sysconfdir='${prefix}/etc'
1258 sharedstatedir='${prefix}/com'
1259 localstatedir='${prefix}/var'
1260 includedir='${prefix}/include'
1261 oldincludedir='/usr/include'
1262 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1263 infodir='${datarootdir}/info'
1264 htmldir='${docdir}'
1265 dvidir='${docdir}'
1266 pdfdir='${docdir}'
1267 psdir='${docdir}'
1268 libdir='${exec_prefix}/lib'
1269 localedir='${datarootdir}/locale'
1270 mandir='${datarootdir}/man'
1271
1272 ac_prev=
1273 ac_dashdash=
1274 for ac_option
1275 do
1276 # If the previous option needs an argument, assign it.
1277 if test -n "$ac_prev"; then
1278 eval $ac_prev=\$ac_option
1279 ac_prev=
1280 continue
1281 fi
1282
1283 case $ac_option in
1284 *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1285 *=) ac_optarg= ;;
1286 *) ac_optarg=yes ;;
1287 esac
1288
1289 # Accept the important Cygnus configure options, so we can diagnose typos.
1290
1291 case $ac_dashdash$ac_option in
1292 --)
1293 ac_dashdash=yes ;;
1294
1295 -bindir | --bindir | --bindi | --bind | --bin | --bi)
1296 ac_prev=bindir ;;
1297 -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1298 bindir=$ac_optarg ;;
1299
1300 -build | --build | --buil | --bui | --bu)
1301 ac_prev=build_alias ;;
1302 -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1303 build_alias=$ac_optarg ;;
1304
1305 -cache-file | --cache-file | --cache-fil | --cache-fi \
1306 | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1307 ac_prev=cache_file ;;
1308 -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1309 | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1310 cache_file=$ac_optarg ;;
1311
1312 --config-cache | -C)
1313 cache_file=config.cache ;;
1314
1315 -datadir | --datadir | --datadi | --datad)
1316 ac_prev=datadir ;;
1317 -datadir=* | --datadir=* | --datadi=* | --datad=*)
1318 datadir=$ac_optarg ;;
1319
1320 -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1321 | --dataroo | --dataro | --datar)
1322 ac_prev=datarootdir ;;
1323 -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1324 | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1325 datarootdir=$ac_optarg ;;
1326
1327 -disable-* | --disable-*)
1328 ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1329 # Reject names that are not valid shell variable names.
1330 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1331 as_fn_error $? "invalid feature name: $ac_useropt"
1332 ac_useropt_orig=$ac_useropt
1333 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1334 case $ac_user_opts in
1335 *"
1336 "enable_$ac_useropt"
1337 "*) ;;
1338 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1339 ac_unrecognized_sep=', ';;
1340 esac
1341 eval enable_$ac_useropt=no ;;
1342
1343 -docdir | --docdir | --docdi | --doc | --do)
1344 ac_prev=docdir ;;
1345 -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1346 docdir=$ac_optarg ;;
1347
1348 -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1349 ac_prev=dvidir ;;
1350 -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1351 dvidir=$ac_optarg ;;
1352
1353 -enable-* | --enable-*)
1354 ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1355 # Reject names that are not valid shell variable names.
1356 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1357 as_fn_error $? "invalid feature name: $ac_useropt"
1358 ac_useropt_orig=$ac_useropt
1359 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1360 case $ac_user_opts in
1361 *"
1362 "enable_$ac_useropt"
1363 "*) ;;
1364 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1365 ac_unrecognized_sep=', ';;
1366 esac
1367 eval enable_$ac_useropt=\$ac_optarg ;;
1368
1369 -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1370 | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1371 | --exec | --exe | --ex)
1372 ac_prev=exec_prefix ;;
1373 -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1374 | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1375 | --exec=* | --exe=* | --ex=*)
1376 exec_prefix=$ac_optarg ;;
1377
1378 -gas | --gas | --ga | --g)
1379 # Obsolete; use --with-gas.
1380 with_gas=yes ;;
1381
1382 -help | --help | --hel | --he | -h)
1383 ac_init_help=long ;;
1384 -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1385 ac_init_help=recursive ;;
1386 -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1387 ac_init_help=short ;;
1388
1389 -host | --host | --hos | --ho)
1390 ac_prev=host_alias ;;
1391 -host=* | --host=* | --hos=* | --ho=*)
1392 host_alias=$ac_optarg ;;
1393
1394 -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1395 ac_prev=htmldir ;;
1396 -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1397 | --ht=*)
1398 htmldir=$ac_optarg ;;
1399
1400 -includedir | --includedir | --includedi | --included | --include \
1401 | --includ | --inclu | --incl | --inc)
1402 ac_prev=includedir ;;
1403 -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1404 | --includ=* | --inclu=* | --incl=* | --inc=*)
1405 includedir=$ac_optarg ;;
1406
1407 -infodir | --infodir | --infodi | --infod | --info | --inf)
1408 ac_prev=infodir ;;
1409 -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1410 infodir=$ac_optarg ;;
1411
1412 -libdir | --libdir | --libdi | --libd)
1413 ac_prev=libdir ;;
1414 -libdir=* | --libdir=* | --libdi=* | --libd=*)
1415 libdir=$ac_optarg ;;
1416
1417 -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1418 | --libexe | --libex | --libe)
1419 ac_prev=libexecdir ;;
1420 -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1421 | --libexe=* | --libex=* | --libe=*)
1422 libexecdir=$ac_optarg ;;
1423
1424 -localedir | --localedir | --localedi | --localed | --locale)
1425 ac_prev=localedir ;;
1426 -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1427 localedir=$ac_optarg ;;
1428
1429 -localstatedir | --localstatedir | --localstatedi | --localstated \
1430 | --localstate | --localstat | --localsta | --localst | --locals)
1431 ac_prev=localstatedir ;;
1432 -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1433 | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1434 localstatedir=$ac_optarg ;;
1435
1436 -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1437 ac_prev=mandir ;;
1438 -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1439 mandir=$ac_optarg ;;
1440
1441 -nfp | --nfp | --nf)
1442 # Obsolete; use --without-fp.
1443 with_fp=no ;;
1444
1445 -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1446 | --no-cr | --no-c | -n)
1447 no_create=yes ;;
1448
1449 -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1450 | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1451 no_recursion=yes ;;
1452
1453 -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1454 | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1455 | --oldin | --oldi | --old | --ol | --o)
1456 ac_prev=oldincludedir ;;
1457 -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1458 | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1459 | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1460 oldincludedir=$ac_optarg ;;
1461
1462 -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1463 ac_prev=prefix ;;
1464 -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1465 prefix=$ac_optarg ;;
1466
1467 -program-prefix | --program-prefix | --program-prefi | --program-pref \
1468 | --program-pre | --program-pr | --program-p)
1469 ac_prev=program_prefix ;;
1470 -program-prefix=* | --program-prefix=* | --program-prefi=* \
1471 | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1472 program_prefix=$ac_optarg ;;
1473
1474 -program-suffix | --program-suffix | --program-suffi | --program-suff \
1475 | --program-suf | --program-su | --program-s)
1476 ac_prev=program_suffix ;;
1477 -program-suffix=* | --program-suffix=* | --program-suffi=* \
1478 | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1479 program_suffix=$ac_optarg ;;
1480
1481 -program-transform-name | --program-transform-name \
1482 | --program-transform-nam | --program-transform-na \
1483 | --program-transform-n | --program-transform- \
1484 | --program-transform | --program-transfor \
1485 | --program-transfo | --program-transf \
1486 | --program-trans | --program-tran \
1487 | --progr-tra | --program-tr | --program-t)
1488 ac_prev=program_transform_name ;;
1489 -program-transform-name=* | --program-transform-name=* \
1490 | --program-transform-nam=* | --program-transform-na=* \
1491 | --program-transform-n=* | --program-transform-=* \
1492 | --program-transform=* | --program-transfor=* \
1493 | --program-transfo=* | --program-transf=* \
1494 | --program-trans=* | --program-tran=* \
1495 | --progr-tra=* | --program-tr=* | --program-t=*)
1496 program_transform_name=$ac_optarg ;;
1497
1498 -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1499 ac_prev=pdfdir ;;
1500 -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1501 pdfdir=$ac_optarg ;;
1502
1503 -psdir | --psdir | --psdi | --psd | --ps)
1504 ac_prev=psdir ;;
1505 -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1506 psdir=$ac_optarg ;;
1507
1508 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1509 | -silent | --silent | --silen | --sile | --sil)
1510 silent=yes ;;
1511
1512 -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1513 ac_prev=sbindir ;;
1514 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1515 | --sbi=* | --sb=*)
1516 sbindir=$ac_optarg ;;
1517
1518 -sharedstatedir | --sharedstatedir | --sharedstatedi \
1519 | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1520 | --sharedst | --shareds | --shared | --share | --shar \
1521 | --sha | --sh)
1522 ac_prev=sharedstatedir ;;
1523 -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1524 | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1525 | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1526 | --sha=* | --sh=*)
1527 sharedstatedir=$ac_optarg ;;
1528
1529 -site | --site | --sit)
1530 ac_prev=site ;;
1531 -site=* | --site=* | --sit=*)
1532 site=$ac_optarg ;;
1533
1534 -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1535 ac_prev=srcdir ;;
1536 -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1537 srcdir=$ac_optarg ;;
1538
1539 -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1540 | --syscon | --sysco | --sysc | --sys | --sy)
1541 ac_prev=sysconfdir ;;
1542 -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1543 | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1544 sysconfdir=$ac_optarg ;;
1545
1546 -target | --target | --targe | --targ | --tar | --ta | --t)
1547 ac_prev=target_alias ;;
1548 -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1549 target_alias=$ac_optarg ;;
1550
1551 -v | -verbose | --verbose | --verbos | --verbo | --verb)
1552 verbose=yes ;;
1553
1554 -version | --version | --versio | --versi | --vers | -V)
1555 ac_init_version=: ;;
1556
1557 -with-* | --with-*)
1558 ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1559 # Reject names that are not valid shell variable names.
1560 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1561 as_fn_error $? "invalid package name: $ac_useropt"
1562 ac_useropt_orig=$ac_useropt
1563 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1564 case $ac_user_opts in
1565 *"
1566 "with_$ac_useropt"
1567 "*) ;;
1568 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1569 ac_unrecognized_sep=', ';;
1570 esac
1571 eval with_$ac_useropt=\$ac_optarg ;;
1572
1573 -without-* | --without-*)
1574 ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1575 # Reject names that are not valid shell variable names.
1576 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1577 as_fn_error $? "invalid package name: $ac_useropt"
1578 ac_useropt_orig=$ac_useropt
1579 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1580 case $ac_user_opts in
1581 *"
1582 "with_$ac_useropt"
1583 "*) ;;
1584 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1585 ac_unrecognized_sep=', ';;
1586 esac
1587 eval with_$ac_useropt=no ;;
1588
1589 --x)
1590 # Obsolete; use --with-x.
1591 with_x=yes ;;
1592
1593 -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1594 | --x-incl | --x-inc | --x-in | --x-i)
1595 ac_prev=x_includes ;;
1596 -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1597 | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1598 x_includes=$ac_optarg ;;
1599
1600 -x-libraries | --x-libraries | --x-librarie | --x-librari \
1601 | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1602 ac_prev=x_libraries ;;
1603 -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1604 | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1605 x_libraries=$ac_optarg ;;
1606
1607 -*) as_fn_error $? "unrecognized option: \`$ac_option'
1608 Try \`$0 --help' for more information"
1609 ;;
1610
1611 *=*)
1612 ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1613 # Reject names that are not valid shell variable names.
1614 case $ac_envvar in #(
1615 '' | [0-9]* | *[!_$as_cr_alnum]* )
1616 as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1617 esac
1618 eval $ac_envvar=\$ac_optarg
1619 export $ac_envvar ;;
1620
1621 *)
1622 # FIXME: should be removed in autoconf 3.0.
1623 $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1624 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1625 $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1626 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1627 ;;
1628
1629 esac
1630 done
1631
1632 if test -n "$ac_prev"; then
1633 ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1634 as_fn_error $? "missing argument to $ac_option"
1635 fi
1636
1637 if test -n "$ac_unrecognized_opts"; then
1638 case $enable_option_checking in
1639 no) ;;
1640 fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1641 *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1642 esac
1643 fi
1644
1645 # Check all directory arguments for consistency.
1646 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
1647 datadir sysconfdir sharedstatedir localstatedir includedir \
1648 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1649 libdir localedir mandir
1650 do
1651 eval ac_val=\$$ac_var
1652 # Remove trailing slashes.
1653 case $ac_val in
1654 */ )
1655 ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1656 eval $ac_var=\$ac_val;;
1657 esac
1658 # Be sure to have absolute directory names.
1659 case $ac_val in
1660 [\\/$]* | ?:[\\/]* ) continue;;
1661 NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1662 esac
1663 as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1664 done
1665
1666 # There might be people who depend on the old broken behavior: `$host'
1667 # used to hold the argument of --host etc.
1668 # FIXME: To remove some day.
1669 build=$build_alias
1670 host=$host_alias
1671 target=$target_alias
1672
1673 # FIXME: To remove some day.
1674 if test "x$host_alias" != x; then
1675 if test "x$build_alias" = x; then
1676 cross_compiling=maybe
1677 elif test "x$build_alias" != "x$host_alias"; then
1678 cross_compiling=yes
1679 fi
1680 fi
1681
1682 ac_tool_prefix=
1683 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1684
1685 test "$silent" = yes && exec 6>/dev/null
1686
1687
1688 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1689 ac_ls_di=`ls -di .` &&
1690 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1691 as_fn_error $? "working directory cannot be determined"
1692 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1693 as_fn_error $? "pwd does not report name of working directory"
1694
1695
1696 # Find the source files, if location was not specified.
1697 if test -z "$srcdir"; then
1698 ac_srcdir_defaulted=yes
1699 # Try the directory containing this script, then the parent directory.
1700 ac_confdir=`$as_dirname -- "$as_myself" ||
1701 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1702 X"$as_myself" : 'X\(//\)[^/]' \| \
1703 X"$as_myself" : 'X\(//\)$' \| \
1704 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1705 $as_echo X"$as_myself" |
1706 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1707 s//\1/
1708 q
1709 }
1710 /^X\(\/\/\)[^/].*/{
1711 s//\1/
1712 q
1713 }
1714 /^X\(\/\/\)$/{
1715 s//\1/
1716 q
1717 }
1718 /^X\(\/\).*/{
1719 s//\1/
1720 q
1721 }
1722 s/.*/./; q'`
1723 srcdir=$ac_confdir
1724 if test ! -r "$srcdir/$ac_unique_file"; then
1725 srcdir=..
1726 fi
1727 else
1728 ac_srcdir_defaulted=no
1729 fi
1730 if test ! -r "$srcdir/$ac_unique_file"; then
1731 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1732 as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1733 fi
1734 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1735 ac_abs_confdir=`(
1736 cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1737 pwd)`
1738 # When building in place, set srcdir=.
1739 if test "$ac_abs_confdir" = "$ac_pwd"; then
1740 srcdir=.
1741 fi
1742 # Remove unnecessary trailing slashes from srcdir.
1743 # Double slashes in file names in object file debugging info
1744 # mess up M-x gdb in Emacs.
1745 case $srcdir in
1746 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1747 esac
1748 for ac_var in $ac_precious_vars; do
1749 eval ac_env_${ac_var}_set=\${${ac_var}+set}
1750 eval ac_env_${ac_var}_value=\$${ac_var}
1751 eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1752 eval ac_cv_env_${ac_var}_value=\$${ac_var}
1753 done
1754
1755 #
1756 # Report the --help message.
1757 #
1758 if test "$ac_init_help" = "long"; then
1759 # Omit some internal or obsolete options to make the list less imposing.
1760 # This message is too long to be a string in the A/UX 3.1 sh.
1761 cat <<_ACEOF
1762 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1763
1764 Usage: $0 [OPTION]... [VAR=VALUE]...
1765
1766 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1767 VAR=VALUE. See below for descriptions of some of the useful variables.
1768
1769 Defaults for the options are specified in brackets.
1770
1771 Configuration:
1772 -h, --help display this help and exit
1773 --help=short display options specific to this package
1774 --help=recursive display the short help of all the included packages
1775 -V, --version display version information and exit
1776 -q, --quiet, --silent do not print \`checking ...' messages
1777 --cache-file=FILE cache test results in FILE [disabled]
1778 -C, --config-cache alias for \`--cache-file=config.cache'
1779 -n, --no-create do not create output files
1780 --srcdir=DIR find the sources in DIR [configure dir or \`..']
1781
1782 Installation directories:
1783 --prefix=PREFIX install architecture-independent files in PREFIX
1784 [$ac_default_prefix]
1785 --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
1786 [PREFIX]
1787
1788 By default, \`make install' will install all the files in
1789 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
1790 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1791 for instance \`--prefix=\$HOME'.
1792
1793 For better control, use the options below.
1794
1795 Fine tuning of the installation directories:
1796 --bindir=DIR user executables [EPREFIX/bin]
1797 --sbindir=DIR system admin executables [EPREFIX/sbin]
1798 --libexecdir=DIR program executables [EPREFIX/libexec]
1799 --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
1800 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
1801 --localstatedir=DIR modifiable single-machine data [PREFIX/var]
1802 --libdir=DIR object code libraries [EPREFIX/lib]
1803 --includedir=DIR C header files [PREFIX/include]
1804 --oldincludedir=DIR C header files for non-gcc [/usr/include]
1805 --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
1806 --datadir=DIR read-only architecture-independent data [DATAROOTDIR]
1807 --infodir=DIR info documentation [DATAROOTDIR/info]
1808 --localedir=DIR locale-dependent data [DATAROOTDIR/locale]
1809 --mandir=DIR man documentation [DATAROOTDIR/man]
1810 --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk]
1811 --htmldir=DIR html documentation [DOCDIR]
1812 --dvidir=DIR dvi documentation [DOCDIR]
1813 --pdfdir=DIR pdf documentation [DOCDIR]
1814 --psdir=DIR ps documentation [DOCDIR]
1815 _ACEOF
1816
1817 cat <<\_ACEOF
1818
1819 X features:
1820 --x-includes=DIR X include files are in DIR
1821 --x-libraries=DIR X library files are in DIR
1822
1823 System types:
1824 --build=BUILD configure for building on BUILD [guessed]
1825 --host=HOST cross-compile to build programs to run on HOST [BUILD]
1826 --target=TARGET configure for building compilers for TARGET [HOST]
1827 _ACEOF
1828 fi
1829
1830 if test -n "$ac_init_help"; then
1831 case $ac_init_help in
1832 short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1833 esac
1834 cat <<\_ACEOF
1835
1836 Optional Features:
1837 --disable-option-checking ignore unrecognized --enable/--with options
1838 --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
1839 --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
1840 --enable-openjdk-only suppress building custom source even if present
1841 [disabled]
1842 --enable-debug set the debug level to fastdebug (shorthand for
1843 --with-debug-level=fastdebug) [disabled]
1844 --disable-headful disable building headful support (graphical UI
1845 support) [enabled]
1846 --enable-hotspot-test-in-build
1847 run the Queens test after Hotspot build [disabled]
1848 --enable-unlimited-crypto
1849 Enable unlimited crypto policy [disabled]
1850 --enable-rmiconnector-iiop
1851 enable the JMX RMIConnector iiop transport
1852 [disabled]
1853 --disable-debug-symbols disable generation of debug symbols [enabled]
1854 --disable-zip-debug-info
1855 disable zipping of debug-info files [enabled]
1856 --disable-freetype-bundling
1857 disable bundling of the freetype library with the
1858 build result [enabled on Windows or when using
1859 --with-freetype, disabled otherwise]
1860 --enable-sjavac use sjavac to do fast incremental compiles
1861 [disabled]
1862 --disable-precompiled-headers
1863 disable using precompiled headers when compiling C++
1864 [enabled]
1865 --enable-ccache enable using ccache to speed up recompilations
1866 [disabled]
1867
1868 Optional Packages:
1869 --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
1870 --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
1871 --with-target-bits build 32-bit or 64-bit binaries (for platforms that
1872 support it), e.g. --with-target-bits=32 [guessed]
1873 --with-custom-make-dir Deprecated. Option is kept for backwards
1874 compatibility and is ignored
1875 --with-jdk-variant JDK variant to build (normal) [normal]
1876 --with-jvm-interpreter JVM interpreter to build (template, cpp) [template]
1877 --with-jvm-variants JVM variants (separated by commas) to build (server,
1878 client, minimal1, kernel, zero, zeroshark, core)
1879 [server]
1880 --with-debug-level set the debug level (release, fastdebug, slowdebug,
1881 optimized (HotSpot build only)) [release]
1882 --with-devkit use this devkit for compilers, tools and resources
1883 --with-sys-root alias for --with-sysroot for backwards compatability
1884 --with-sysroot use this directory as sysroot
1885 --with-tools-dir alias for --with-toolchain-path for backwards
1886 compatibility
1887 --with-toolchain-path prepend these directories when searching for
1888 toolchain binaries (compilers etc)
1889 --with-extra-path prepend these directories to the default path
1890 --with-sdk-name use the platform SDK of the given name. [macosx]
1891 --with-conf-name use this as the name of the configuration [generated
1892 from important configuration options]
1893 --with-output-sync set make output sync type if supported by make.
1894 [recurse]
1895 --with-builddeps-conf use this configuration file for the builddeps
1896 --with-builddeps-server download and use build dependencies from this server
1897 url
1898 --with-builddeps-dir store downloaded build dependencies here
1899 [/localhome/builddeps]
1900 --with-builddeps-group chgrp the downloaded build dependencies to this
1901 group
1902 --with-cacerts-file specify alternative cacerts file
1903 --with-milestone Set milestone value for build [internal]
1904 --with-update-version Set update version value for build [b00]
1905 --with-user-release-suffix
1906 Add a custom string to the version string if build
1907 number is not set.[username_builddateb00]
1908 --with-build-number Set build number value for build [b00]
1909 --with-copyright-year Set copyright year value for build [current year]
1910 --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed]
1911 --with-add-source-root for each and every source directory, look in this
1912 additional source root for the same directory; if it
1913 exists and have files in it, include it in the build
1914 --with-override-source-root
1915 for each and every source directory, look in this
1916 override source root for the same directory; if it
1917 exists, use that directory instead and ignore the
1918 directory in the original source root
1919 --with-adds-and-overrides
1920 use the subdirs 'adds' and 'overrides' in the
1921 specified directory as add-source-root and
1922 override-source-root
1923 --with-override-langtools
1924 use this langtools dir for the build
1925 --with-override-corba use this corba dir for the build
1926 --with-override-jaxp use this jaxp dir for the build
1927 --with-override-jaxws use this jaxws dir for the build
1928 --with-override-hotspot use this hotspot dir for the build
1929 --with-override-nashorn use this nashorn dir for the build
1930 --with-override-jdk use this jdk dir for the build
1931 --with-import-hotspot import hotspot binaries from this jdk image or
1932 hotspot build dist dir instead of building from
1933 source
1934 --with-toolchain-type the toolchain type (or family) to use, use '--help'
1935 to show possible values [platform dependent]
1936 --with-toolchain-version
1937 the version of the toolchain to look for, use
1938 '--help' to show possible values [platform
1939 dependent]
1940 --with-jtreg Regression Test Harness [probed]
1941 --with-extra-cflags extra flags to be used when compiling jdk c-files
1942 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
1943 --with-extra-ldflags extra flags to be used when linking jdk
1944 --with-x use the X Window System
1945 --with-cups specify prefix directory for the cups package
1946 (expecting the headers under PATH/include)
1947 --with-cups-include specify directory for the cups include files
1948 --with-freetype specify prefix directory for the freetype package
1949 (expecting the libraries under PATH/lib and the
1950 headers under PATH/include)
1951 --with-freetype-include specify directory for the freetype include files
1952 --with-freetype-lib specify directory for the freetype library
1953 --with-freetype-src specify directory with freetype sources to
1954 automatically build the library (experimental,
1955 Windows-only)
1956 --with-alsa specify prefix directory for the alsa package
1957 (expecting the libraries under PATH/lib and the
1958 headers under PATH/include)
1959 --with-alsa-include specify directory for the alsa include files
1960 --with-alsa-lib specify directory for the alsa library
1961 --with-libjpeg use libjpeg from build system or OpenJDK source
1962 (system, bundled) [bundled]
1963 --with-giflib use giflib from build system or OpenJDK source
1964 (system, bundled) [bundled]
1965 --with-lcms use lcms2 from build system or OpenJDK source
1966 (system, bundled) [bundled]
1967 --with-libpng use libpng from build system or OpenJDK source
1968 (system, bundled) [bundled]
1969 --with-zlib use zlib from build system or OpenJDK source
1970 (system, bundled) [bundled]
1971 --with-stdc++lib=<static>,<dynamic>,<default>
1972 force linking of the C++ runtime on Linux to either
1973 static or dynamic, default is static with dynamic as
1974 fallback
1975 --with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
1976 (Windows only) [probed]
1977 --with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
1978 (Windows only) [probed]
1979 --with-dxsdk Deprecated. Option is kept for backwards
1980 compatibility and is ignored
1981 --with-dxsdk-lib Deprecated. Option is kept for backwards
1982 compatibility and is ignored
1983 --with-dxsdk-include Deprecated. Option is kept for backwards
1984 compatibility and is ignored
1985 --with-num-cores number of cores in the build system, e.g.
1986 --with-num-cores=8 [probed]
1987 --with-memory-size memory (in MB) available in the build system, e.g.
1988 --with-memory-size=1024 [probed]
1989 --with-jobs number of parallel jobs to let make run [calculated
1990 based on cores and memory]
1991 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1992 invocations of boot JDK, overriding the default
1993 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1994 -enableassertions"
1995 --with-sjavac-server-java
1996 use this java binary for running the sjavac
1997 background server [Boot JDK java]
1998 --with-ccache-dir where to store ccache files [~/.ccache]
1999
2000 Some influential environment variables:
2001 BASENAME Override default value for BASENAME
2002 BASH Override default value for BASH
2003 CAT Override default value for CAT
2004 CHMOD Override default value for CHMOD
2005 CMP Override default value for CMP
2006 COMM Override default value for COMM
2007 CP Override default value for CP
2008 CUT Override default value for CUT
2009 DATE Override default value for DATE
2010 DIFF Override default value for DIFF
2011 DIRNAME Override default value for DIRNAME
2012 ECHO Override default value for ECHO
2013 EXPR Override default value for EXPR
2014 FILE Override default value for FILE
2015 FIND Override default value for FIND
2016 HEAD Override default value for HEAD
2017 LN Override default value for LN
2018 LS Override default value for LS
2019 MKDIR Override default value for MKDIR
2020 MKTEMP Override default value for MKTEMP
2021 MV Override default value for MV
2022 NAWK Override default value for NAWK
2023 PRINTF Override default value for PRINTF
2024 RM Override default value for RM
2025 SH Override default value for SH
2026 SORT Override default value for SORT
2027 TAIL Override default value for TAIL
2028 TAR Override default value for TAR
2029 TEE Override default value for TEE
2030 TOUCH Override default value for TOUCH
2031 TR Override default value for TR
2032 UNAME Override default value for UNAME
2033 UNIQ Override default value for UNIQ
2034 WC Override default value for WC
2035 WHICH Override default value for WHICH
2036 XARGS Override default value for XARGS
2037 AWK Override default value for AWK
2038 GREP Override default value for GREP
2039 EGREP Override default value for EGREP
2040 FGREP Override default value for FGREP
2041 SED Override default value for SED
2042 CYGPATH Override default value for CYGPATH
2043 READLINK Override default value for READLINK
2044 DF Override default value for DF
2045 SETFILE Override default value for SETFILE
2046 CPIO Override default value for CPIO
2047 UNZIP Override default value for UNZIP
2048 ZIP Override default value for ZIP
2049 LDD Override default value for LDD
2050 OTOOL Override default value for OTOOL
2051 READELF Override default value for READELF
2052 HG Override default value for HG
2053 STAT Override default value for STAT
2054 TIME Override default value for TIME
2055 DSYMUTIL Override default value for DSYMUTIL
2056 XATTR Override default value for XATTR
2057 CODESIGN Override default value for CODESIGN
2058 PKG_CONFIG path to pkg-config utility
2059 JAVA Override default value for JAVA
2060 JAVAC Override default value for JAVAC
2061 JAVAH Override default value for JAVAH
2062 JAR Override default value for JAR
2063 NATIVE2ASCII
2064 Override default value for NATIVE2ASCII
2065 JARSIGNER Override default value for JARSIGNER
2066 CC C compiler command
2067 CFLAGS C compiler flags
2068 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
2069 nonstandard directory <lib dir>
2070 LIBS libraries to pass to the linker, e.g. -l<library>
2071 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2072 you have headers in a nonstandard directory <include dir>
2073 CXX C++ compiler command
2074 CXXFLAGS C++ compiler flags
2075 CPP C preprocessor
2076 CXXCPP C++ preprocessor
2077 AS Override default value for AS
2078 AR Override default value for AR
2079 LIPO Override default value for LIPO
2080 STRIP Override default value for STRIP
2081 NM Override default value for NM
2082 GNM Override default value for GNM
2083 MCS Override default value for MCS
2084 OBJCOPY Override default value for OBJCOPY
2085 OBJDUMP Override default value for OBJDUMP
2086 BUILD_CC Override default value for BUILD_CC
2087 BUILD_CXX Override default value for BUILD_CXX
2088 BUILD_LD Override default value for BUILD_LD
2089 JTREGEXE Override default value for JTREGEXE
2090 XMKMF Path to xmkmf, Makefile generator for X Window System
2091 FREETYPE_CFLAGS
2092 C compiler flags for FREETYPE, overriding pkg-config
2093 FREETYPE_LIBS
2094 linker flags for FREETYPE, overriding pkg-config
2095 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2096 ALSA_LIBS linker flags for ALSA, overriding pkg-config
2097 LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2098 LCMS_LIBS linker flags for LCMS, overriding pkg-config
2099 PNG_CFLAGS C compiler flags for PNG, overriding pkg-config
2100 PNG_LIBS linker flags for PNG, overriding pkg-config
2101 LIBFFI_CFLAGS
2102 C compiler flags for LIBFFI, overriding pkg-config
2103 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2104 CCACHE Override default value for CCACHE
2105
2106 Use these variables to override the choices made by `configure' or to help
2107 it to find libraries and programs with nonstandard names/locations.
2108
2109 Report bugs to <build-dev@openjdk.java.net>.
2110 OpenJDK home page: <http://openjdk.java.net>.
2111 _ACEOF
2112 ac_status=$?
2113 fi
2114
2115 if test "$ac_init_help" = "recursive"; then
2116 # If there are subdirs, report their specific --help.
2117 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2118 test -d "$ac_dir" ||
2119 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2120 continue
2121 ac_builddir=.
2122
2123 case "$ac_dir" in
2124 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2125 *)
2126 ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2127 # A ".." for each directory in $ac_dir_suffix.
2128 ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2129 case $ac_top_builddir_sub in
2130 "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2131 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2132 esac ;;
2133 esac
2134 ac_abs_top_builddir=$ac_pwd
2135 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2136 # for backward compatibility:
2137 ac_top_builddir=$ac_top_build_prefix
2138
2139 case $srcdir in
2140 .) # We are building in place.
2141 ac_srcdir=.
2142 ac_top_srcdir=$ac_top_builddir_sub
2143 ac_abs_top_srcdir=$ac_pwd ;;
2144 [\\/]* | ?:[\\/]* ) # Absolute name.
2145 ac_srcdir=$srcdir$ac_dir_suffix;
2146 ac_top_srcdir=$srcdir
2147 ac_abs_top_srcdir=$srcdir ;;
2148 *) # Relative name.
2149 ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2150 ac_top_srcdir=$ac_top_build_prefix$srcdir
2151 ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2152 esac
2153 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2154
2155 cd "$ac_dir" || { ac_status=$?; continue; }
2156 # Check for guested configure.
2157 if test -f "$ac_srcdir/configure.gnu"; then
2158 echo &&
2159 $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2160 elif test -f "$ac_srcdir/configure"; then
2161 echo &&
2162 $SHELL "$ac_srcdir/configure" --help=recursive
2163 else
2164 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2165 fi || ac_status=$?
2166 cd "$ac_pwd" || { ac_status=$?; break; }
2167 done
2168 fi
2169
2170 test -n "$ac_init_help" && exit $ac_status
2171 if $ac_init_version; then
2172 cat <<\_ACEOF
2173 OpenJDK configure jdk9
2174 generated by GNU Autoconf 2.69
2175
2176 Copyright (C) 2012 Free Software Foundation, Inc.
2177 This configure script is free software; the Free Software Foundation
2178 gives unlimited permission to copy, distribute and modify it.
2179 _ACEOF
2180 exit
2181 fi
2182
2183 ## ------------------------ ##
2184 ## Autoconf initialization. ##
2185 ## ------------------------ ##
2186
2187 # ac_fn_c_try_compile LINENO
2188 # --------------------------
2189 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2190 ac_fn_c_try_compile ()
2191 {
2192 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2193 rm -f conftest.$ac_objext
2194 if { { ac_try="$ac_compile"
2195 case "(($ac_try" in
2196 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2197 *) ac_try_echo=$ac_try;;
2198 esac
2199 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2200 $as_echo "$ac_try_echo"; } >&5
2201 (eval "$ac_compile") 2>conftest.err
2202 ac_status=$?
2203 if test -s conftest.err; then
2204 grep -v '^ *+' conftest.err >conftest.er1
2205 cat conftest.er1 >&5
2206 mv -f conftest.er1 conftest.err
2207 fi
2208 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2209 test $ac_status = 0; } && {
2210 test -z "$ac_c_werror_flag" ||
2211 test ! -s conftest.err
2212 } && test -s conftest.$ac_objext; then :
2213 ac_retval=0
2214 else
2215 $as_echo "$as_me: failed program was:" >&5
2216 sed 's/^/| /' conftest.$ac_ext >&5
2217
2218 ac_retval=1
2219 fi
2220 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2221 as_fn_set_status $ac_retval
2222
2223 } # ac_fn_c_try_compile
2224
2225 # ac_fn_cxx_try_compile LINENO
2226 # ----------------------------
2227 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2228 ac_fn_cxx_try_compile ()
2229 {
2230 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2231 rm -f conftest.$ac_objext
2232 if { { ac_try="$ac_compile"
2233 case "(($ac_try" in
2234 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2235 *) ac_try_echo=$ac_try;;
2236 esac
2237 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2238 $as_echo "$ac_try_echo"; } >&5
2239 (eval "$ac_compile") 2>conftest.err
2240 ac_status=$?
2241 if test -s conftest.err; then
2242 grep -v '^ *+' conftest.err >conftest.er1
2243 cat conftest.er1 >&5
2244 mv -f conftest.er1 conftest.err
2245 fi
2246 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2247 test $ac_status = 0; } && {
2248 test -z "$ac_cxx_werror_flag" ||
2249 test ! -s conftest.err
2250 } && test -s conftest.$ac_objext; then :
2251 ac_retval=0
2252 else
2253 $as_echo "$as_me: failed program was:" >&5
2254 sed 's/^/| /' conftest.$ac_ext >&5
2255
2256 ac_retval=1
2257 fi
2258 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2259 as_fn_set_status $ac_retval
2260
2261 } # ac_fn_cxx_try_compile
2262
2263 # ac_fn_c_try_cpp LINENO
2264 # ----------------------
2265 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2266 ac_fn_c_try_cpp ()
2267 {
2268 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2269 if { { ac_try="$ac_cpp conftest.$ac_ext"
2270 case "(($ac_try" in
2271 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2272 *) ac_try_echo=$ac_try;;
2273 esac
2274 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2275 $as_echo "$ac_try_echo"; } >&5
2276 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2277 ac_status=$?
2278 if test -s conftest.err; then
2279 grep -v '^ *+' conftest.err >conftest.er1
2280 cat conftest.er1 >&5
2281 mv -f conftest.er1 conftest.err
2282 fi
2283 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2284 test $ac_status = 0; } > conftest.i && {
2285 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2286 test ! -s conftest.err
2287 }; then :
2288 ac_retval=0
2289 else
2290 $as_echo "$as_me: failed program was:" >&5
2291 sed 's/^/| /' conftest.$ac_ext >&5
2292
2293 ac_retval=1
2294 fi
2295 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2296 as_fn_set_status $ac_retval
2297
2298 } # ac_fn_c_try_cpp
2299
2300 # ac_fn_cxx_try_cpp LINENO
2301 # ------------------------
2302 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2303 ac_fn_cxx_try_cpp ()
2304 {
2305 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2306 if { { ac_try="$ac_cpp conftest.$ac_ext"
2307 case "(($ac_try" in
2308 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2309 *) ac_try_echo=$ac_try;;
2310 esac
2311 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2312 $as_echo "$ac_try_echo"; } >&5
2313 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2314 ac_status=$?
2315 if test -s conftest.err; then
2316 grep -v '^ *+' conftest.err >conftest.er1
2317 cat conftest.er1 >&5
2318 mv -f conftest.er1 conftest.err
2319 fi
2320 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2321 test $ac_status = 0; } > conftest.i && {
2322 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2323 test ! -s conftest.err
2324 }; then :
2325 ac_retval=0
2326 else
2327 $as_echo "$as_me: failed program was:" >&5
2328 sed 's/^/| /' conftest.$ac_ext >&5
2329
2330 ac_retval=1
2331 fi
2332 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2333 as_fn_set_status $ac_retval
2334
2335 } # ac_fn_cxx_try_cpp
2336
2337 # ac_fn_c_try_link LINENO
2338 # -----------------------
2339 # Try to link conftest.$ac_ext, and return whether this succeeded.
2340 ac_fn_c_try_link ()
2341 {
2342 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2343 rm -f conftest.$ac_objext conftest$ac_exeext
2344 if { { ac_try="$ac_link"
2345 case "(($ac_try" in
2346 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2347 *) ac_try_echo=$ac_try;;
2348 esac
2349 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2350 $as_echo "$ac_try_echo"; } >&5
2351 (eval "$ac_link") 2>conftest.err
2352 ac_status=$?
2353 if test -s conftest.err; then
2354 grep -v '^ *+' conftest.err >conftest.er1
2355 cat conftest.er1 >&5
2356 mv -f conftest.er1 conftest.err
2357 fi
2358 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2359 test $ac_status = 0; } && {
2360 test -z "$ac_c_werror_flag" ||
2361 test ! -s conftest.err
2362 } && test -s conftest$ac_exeext && {
2363 test "$cross_compiling" = yes ||
2364 test -x conftest$ac_exeext
2365 }; then :
2366 ac_retval=0
2367 else
2368 $as_echo "$as_me: failed program was:" >&5
2369 sed 's/^/| /' conftest.$ac_ext >&5
2370
2371 ac_retval=1
2372 fi
2373 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2374 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2375 # interfere with the next link command; also delete a directory that is
2376 # left behind by Apple's compiler. We do this before executing the actions.
2377 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2378 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2379 as_fn_set_status $ac_retval
2380
2381 } # ac_fn_c_try_link
2382
2383 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2384 # ---------------------------------------------------------
2385 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2386 # the include files in INCLUDES and setting the cache variable VAR
2387 # accordingly.
2388 ac_fn_cxx_check_header_mongrel ()
2389 {
2390 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2391 if eval \${$3+:} false; then :
2392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2393 $as_echo_n "checking for $2... " >&6; }
2394 if eval \${$3+:} false; then :
2395 $as_echo_n "(cached) " >&6
2396 fi
2397 eval ac_res=\$$3
2398 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2399 $as_echo "$ac_res" >&6; }
2400 else
2401 # Is the header compilable?
2402 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2403 $as_echo_n "checking $2 usability... " >&6; }
2404 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2405 /* end confdefs.h. */
2406 $4
2407 #include <$2>
2408 _ACEOF
2409 if ac_fn_cxx_try_compile "$LINENO"; then :
2410 ac_header_compiler=yes
2411 else
2412 ac_header_compiler=no
2413 fi
2414 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2416 $as_echo "$ac_header_compiler" >&6; }
2417
2418 # Is the header present?
2419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2420 $as_echo_n "checking $2 presence... " >&6; }
2421 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2422 /* end confdefs.h. */
2423 #include <$2>
2424 _ACEOF
2425 if ac_fn_cxx_try_cpp "$LINENO"; then :
2426 ac_header_preproc=yes
2427 else
2428 ac_header_preproc=no
2429 fi
2430 rm -f conftest.err conftest.i conftest.$ac_ext
2431 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2432 $as_echo "$ac_header_preproc" >&6; }
2433
2434 # So? What about this header?
2435 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2436 yes:no: )
2437 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2438 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2439 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2440 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2441 ;;
2442 no:yes:* )
2443 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2444 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2445 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
2446 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
2447 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2448 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2449 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
2450 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
2451 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2452 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2453 ( $as_echo "## ----------------------------------------- ##
2454 ## Report this to build-dev@openjdk.java.net ##
2455 ## ----------------------------------------- ##"
2456 ) | sed "s/^/$as_me: WARNING: /" >&2
2457 ;;
2458 esac
2459 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2460 $as_echo_n "checking for $2... " >&6; }
2461 if eval \${$3+:} false; then :
2462 $as_echo_n "(cached) " >&6
2463 else
2464 eval "$3=\$ac_header_compiler"
2465 fi
2466 eval ac_res=\$$3
2467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2468 $as_echo "$ac_res" >&6; }
2469 fi
2470 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2471
2472 } # ac_fn_cxx_check_header_mongrel
2473
2474 # ac_fn_cxx_try_run LINENO
2475 # ------------------------
2476 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2477 # that executables *can* be run.
2478 ac_fn_cxx_try_run ()
2479 {
2480 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2481 if { { ac_try="$ac_link"
2482 case "(($ac_try" in
2483 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2484 *) ac_try_echo=$ac_try;;
2485 esac
2486 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2487 $as_echo "$ac_try_echo"; } >&5
2488 (eval "$ac_link") 2>&5
2489 ac_status=$?
2490 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2491 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2492 { { case "(($ac_try" in
2493 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2494 *) ac_try_echo=$ac_try;;
2495 esac
2496 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2497 $as_echo "$ac_try_echo"; } >&5
2498 (eval "$ac_try") 2>&5
2499 ac_status=$?
2500 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2501 test $ac_status = 0; }; }; then :
2502 ac_retval=0
2503 else
2504 $as_echo "$as_me: program exited with status $ac_status" >&5
2505 $as_echo "$as_me: failed program was:" >&5
2506 sed 's/^/| /' conftest.$ac_ext >&5
2507
2508 ac_retval=$ac_status
2509 fi
2510 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2511 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2512 as_fn_set_status $ac_retval
2513
2514 } # ac_fn_cxx_try_run
2515
2516 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2517 # ---------------------------------------------------------
2518 # Tests whether HEADER exists and can be compiled using the include files in
2519 # INCLUDES, setting the cache variable VAR accordingly.
2520 ac_fn_cxx_check_header_compile ()
2521 {
2522 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2524 $as_echo_n "checking for $2... " >&6; }
2525 if eval \${$3+:} false; then :
2526 $as_echo_n "(cached) " >&6
2527 else
2528 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2529 /* end confdefs.h. */
2530 $4
2531 #include <$2>
2532 _ACEOF
2533 if ac_fn_cxx_try_compile "$LINENO"; then :
2534 eval "$3=yes"
2535 else
2536 eval "$3=no"
2537 fi
2538 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2539 fi
2540 eval ac_res=\$$3
2541 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2542 $as_echo "$ac_res" >&6; }
2543 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2544
2545 } # ac_fn_cxx_check_header_compile
2546
2547 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2548 # ----------------------------------------------
2549 # Tries to find the compile-time value of EXPR in a program that includes
2550 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2551 # computed
2552 ac_fn_cxx_compute_int ()
2553 {
2554 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2555 if test "$cross_compiling" = yes; then
2556 # Depending upon the size, compute the lo and hi bounds.
2557 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2558 /* end confdefs.h. */
2559 $4
2560 int
2561 main ()
2562 {
2563 static int test_array [1 - 2 * !(($2) >= 0)];
2564 test_array [0] = 0;
2565 return test_array [0];
2566
2567 ;
2568 return 0;
2569 }
2570 _ACEOF
2571 if ac_fn_cxx_try_compile "$LINENO"; then :
2572 ac_lo=0 ac_mid=0
2573 while :; do
2574 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2575 /* end confdefs.h. */
2576 $4
2577 int
2578 main ()
2579 {
2580 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2581 test_array [0] = 0;
2582 return test_array [0];
2583
2584 ;
2585 return 0;
2586 }
2587 _ACEOF
2588 if ac_fn_cxx_try_compile "$LINENO"; then :
2589 ac_hi=$ac_mid; break
2590 else
2591 as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2592 if test $ac_lo -le $ac_mid; then
2593 ac_lo= ac_hi=
2594 break
2595 fi
2596 as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2597 fi
2598 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2599 done
2600 else
2601 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2602 /* end confdefs.h. */
2603 $4
2604 int
2605 main ()
2606 {
2607 static int test_array [1 - 2 * !(($2) < 0)];
2608 test_array [0] = 0;
2609 return test_array [0];
2610
2611 ;
2612 return 0;
2613 }
2614 _ACEOF
2615 if ac_fn_cxx_try_compile "$LINENO"; then :
2616 ac_hi=-1 ac_mid=-1
2617 while :; do
2618 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2619 /* end confdefs.h. */
2620 $4
2621 int
2622 main ()
2623 {
2624 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2625 test_array [0] = 0;
2626 return test_array [0];
2627
2628 ;
2629 return 0;
2630 }
2631 _ACEOF
2632 if ac_fn_cxx_try_compile "$LINENO"; then :
2633 ac_lo=$ac_mid; break
2634 else
2635 as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2636 if test $ac_mid -le $ac_hi; then
2637 ac_lo= ac_hi=
2638 break
2639 fi
2640 as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2641 fi
2642 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2643 done
2644 else
2645 ac_lo= ac_hi=
2646 fi
2647 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2648 fi
2649 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2650 # Binary search between lo and hi bounds.
2651 while test "x$ac_lo" != "x$ac_hi"; do
2652 as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2653 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2654 /* end confdefs.h. */
2655 $4
2656 int
2657 main ()
2658 {
2659 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2660 test_array [0] = 0;
2661 return test_array [0];
2662
2663 ;
2664 return 0;
2665 }
2666 _ACEOF
2667 if ac_fn_cxx_try_compile "$LINENO"; then :
2668 ac_hi=$ac_mid
2669 else
2670 as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2671 fi
2672 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2673 done
2674 case $ac_lo in #((
2675 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2676 '') ac_retval=1 ;;
2677 esac
2678 else
2679 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2680 /* end confdefs.h. */
2681 $4
2682 static long int longval () { return $2; }
2683 static unsigned long int ulongval () { return $2; }
2684 #include <stdio.h>
2685 #include <stdlib.h>
2686 int
2687 main ()
2688 {
2689
2690 FILE *f = fopen ("conftest.val", "w");
2691 if (! f)
2692 return 1;
2693 if (($2) < 0)
2694 {
2695 long int i = longval ();
2696 if (i != ($2))
2697 return 1;
2698 fprintf (f, "%ld", i);
2699 }
2700 else
2701 {
2702 unsigned long int i = ulongval ();
2703 if (i != ($2))
2704 return 1;
2705 fprintf (f, "%lu", i);
2706 }
2707 /* Do not output a trailing newline, as this causes \r\n confusion
2708 on some platforms. */
2709 return ferror (f) || fclose (f) != 0;
2710
2711 ;
2712 return 0;
2713 }
2714 _ACEOF
2715 if ac_fn_cxx_try_run "$LINENO"; then :
2716 echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2717 else
2718 ac_retval=1
2719 fi
2720 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2721 conftest.$ac_objext conftest.beam conftest.$ac_ext
2722 rm -f conftest.val
2723
2724 fi
2725 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2726 as_fn_set_status $ac_retval
2727
2728 } # ac_fn_cxx_compute_int
2729
2730 # ac_fn_cxx_try_link LINENO
2731 # -------------------------
2732 # Try to link conftest.$ac_ext, and return whether this succeeded.
2733 ac_fn_cxx_try_link ()
2734 {
2735 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2736 rm -f conftest.$ac_objext conftest$ac_exeext
2737 if { { ac_try="$ac_link"
2738 case "(($ac_try" in
2739 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2740 *) ac_try_echo=$ac_try;;
2741 esac
2742 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2743 $as_echo "$ac_try_echo"; } >&5
2744 (eval "$ac_link") 2>conftest.err
2745 ac_status=$?
2746 if test -s conftest.err; then
2747 grep -v '^ *+' conftest.err >conftest.er1
2748 cat conftest.er1 >&5
2749 mv -f conftest.er1 conftest.err
2750 fi
2751 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2752 test $ac_status = 0; } && {
2753 test -z "$ac_cxx_werror_flag" ||
2754 test ! -s conftest.err
2755 } && test -s conftest$ac_exeext && {
2756 test "$cross_compiling" = yes ||
2757 test -x conftest$ac_exeext
2758 }; then :
2759 ac_retval=0
2760 else
2761 $as_echo "$as_me: failed program was:" >&5
2762 sed 's/^/| /' conftest.$ac_ext >&5
2763
2764 ac_retval=1
2765 fi
2766 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2767 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2768 # interfere with the next link command; also delete a directory that is
2769 # left behind by Apple's compiler. We do this before executing the actions.
2770 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2771 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2772 as_fn_set_status $ac_retval
2773
2774 } # ac_fn_cxx_try_link
2775
2776 # ac_fn_cxx_check_func LINENO FUNC VAR
2777 # ------------------------------------
2778 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2779 ac_fn_cxx_check_func ()
2780 {
2781 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2782 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2783 $as_echo_n "checking for $2... " >&6; }
2784 if eval \${$3+:} false; then :
2785 $as_echo_n "(cached) " >&6
2786 else
2787 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2788 /* end confdefs.h. */
2789 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2790 For example, HP-UX 11i <limits.h> declares gettimeofday. */
2791 #define $2 innocuous_$2
2792
2793 /* System header to define __stub macros and hopefully few prototypes,
2794 which can conflict with char $2 (); below.
2795 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2796 <limits.h> exists even on freestanding compilers. */
2797
2798 #ifdef __STDC__
2799 # include <limits.h>
2800 #else
2801 # include <assert.h>
2802 #endif
2803
2804 #undef $2
2805
2806 /* Override any GCC internal prototype to avoid an error.
2807 Use char because int might match the return type of a GCC
2808 builtin and then its argument prototype would still apply. */
2809 #ifdef __cplusplus
2810 extern "C"
2811 #endif
2812 char $2 ();
2813 /* The GNU C library defines this for functions which it implements
2814 to always fail with ENOSYS. Some functions are actually named
2815 something starting with __ and the normal name is an alias. */
2816 #if defined __stub_$2 || defined __stub___$2
2817 choke me
2818 #endif
2819
2820 int
2821 main ()
2822 {
2823 return $2 ();
2824 ;
2825 return 0;
2826 }
2827 _ACEOF
2828 if ac_fn_cxx_try_link "$LINENO"; then :
2829 eval "$3=yes"
2830 else
2831 eval "$3=no"
2832 fi
2833 rm -f core conftest.err conftest.$ac_objext \
2834 conftest$ac_exeext conftest.$ac_ext
2835 fi
2836 eval ac_res=\$$3
2837 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2838 $as_echo "$ac_res" >&6; }
2839 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2840
2841 } # ac_fn_cxx_check_func
2842
2843 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2844 # -------------------------------------------------------
2845 # Tests whether HEADER exists and can be compiled using the include files in
2846 # INCLUDES, setting the cache variable VAR accordingly.
2847 ac_fn_c_check_header_compile ()
2848 {
2849 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2850 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2851 $as_echo_n "checking for $2... " >&6; }
2852 if eval \${$3+:} false; then :
2853 $as_echo_n "(cached) " >&6
2854 else
2855 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2856 /* end confdefs.h. */
2857 $4
2858 #include <$2>
2859 _ACEOF
2860 if ac_fn_c_try_compile "$LINENO"; then :
2861 eval "$3=yes"
2862 else
2863 eval "$3=no"
2864 fi
2865 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2866 fi
2867 eval ac_res=\$$3
2868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2869 $as_echo "$ac_res" >&6; }
2870 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2871
2872 } # ac_fn_c_check_header_compile
2873 cat >config.log <<_ACEOF
2874 This file contains any messages produced by compilers while
2875 running configure, to aid debugging if configure makes a mistake.
2876
2877 It was created by OpenJDK $as_me jdk9, which was
2878 generated by GNU Autoconf 2.69. Invocation command line was
2879
2880 $ $0 $@
2881
2882 _ACEOF
2883 exec 5>>config.log
2884 {
2885 cat <<_ASUNAME
2886 ## --------- ##
2887 ## Platform. ##
2888 ## --------- ##
2889
2890 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2891 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2892 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2893 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2894 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2895
2896 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2897 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
2898
2899 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
2900 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
2901 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2902 /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
2903 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
2904 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
2905 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
2906
2907 _ASUNAME
2908
2909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2910 for as_dir in $PATH
2911 do
2912 IFS=$as_save_IFS
2913 test -z "$as_dir" && as_dir=.
2914 $as_echo "PATH: $as_dir"
2915 done
2916 IFS=$as_save_IFS
2917
2918 } >&5
2919
2920 cat >&5 <<_ACEOF
2921
2922
2923 ## ----------- ##
2924 ## Core tests. ##
2925 ## ----------- ##
2926
2927 _ACEOF
2928
2929
2930 # Keep a trace of the command line.
2931 # Strip out --no-create and --no-recursion so they do not pile up.
2932 # Strip out --silent because we don't want to record it for future runs.
2933 # Also quote any args containing shell meta-characters.
2934 # Make two passes to allow for proper duplicate-argument suppression.
2935 ac_configure_args=
2936 ac_configure_args0=
2937 ac_configure_args1=
2938 ac_must_keep_next=false
2939 for ac_pass in 1 2
2940 do
2941 for ac_arg
2942 do
2943 case $ac_arg in
2944 -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2945 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2946 | -silent | --silent | --silen | --sile | --sil)
2947 continue ;;
2948 *\'*)
2949 ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2950 esac
2951 case $ac_pass in
2952 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2953 2)
2954 as_fn_append ac_configure_args1 " '$ac_arg'"
2955 if test $ac_must_keep_next = true; then
2956 ac_must_keep_next=false # Got value, back to normal.
2957 else
2958 case $ac_arg in
2959 *=* | --config-cache | -C | -disable-* | --disable-* \
2960 | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2961 | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2962 | -with-* | --with-* | -without-* | --without-* | --x)
2963 case "$ac_configure_args0 " in
2964 "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2965 esac
2966 ;;
2967 -* ) ac_must_keep_next=true ;;
2968 esac
2969 fi
2970 as_fn_append ac_configure_args " '$ac_arg'"
2971 ;;
2972 esac
2973 done
2974 done
2975 { ac_configure_args0=; unset ac_configure_args0;}
2976 { ac_configure_args1=; unset ac_configure_args1;}
2977
2978 # When interrupted or exit'd, cleanup temporary files, and complete
2979 # config.log. We remove comments because anyway the quotes in there
2980 # would cause problems or look ugly.
2981 # WARNING: Use '\'' to represent an apostrophe within the trap.
2982 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2983 trap 'exit_status=$?
2984 # Save into config.log some information that might help in debugging.
2985 {
2986 echo
2987
2988 $as_echo "## ---------------- ##
2989 ## Cache variables. ##
2990 ## ---------------- ##"
2991 echo
2992 # The following way of writing the cache mishandles newlines in values,
2993 (
2994 for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2995 eval ac_val=\$$ac_var
2996 case $ac_val in #(
2997 *${as_nl}*)
2998 case $ac_var in #(
2999 *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3000 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3001 esac
3002 case $ac_var in #(
3003 _ | IFS | as_nl) ;; #(
3004 BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3005 *) { eval $ac_var=; unset $ac_var;} ;;
3006 esac ;;
3007 esac
3008 done
3009 (set) 2>&1 |
3010 case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3011 *${as_nl}ac_space=\ *)
3012 sed -n \
3013 "s/'\''/'\''\\\\'\'''\''/g;
3014 s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3015 ;; #(
3016 *)
3017 sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3018 ;;
3019 esac |
3020 sort
3021 )
3022 echo
3023
3024 $as_echo "## ----------------- ##
3025 ## Output variables. ##
3026 ## ----------------- ##"
3027 echo
3028 for ac_var in $ac_subst_vars
3029 do
3030 eval ac_val=\$$ac_var
3031 case $ac_val in
3032 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3033 esac
3034 $as_echo "$ac_var='\''$ac_val'\''"
3035 done | sort
3036 echo
3037
3038 if test -n "$ac_subst_files"; then
3039 $as_echo "## ------------------- ##
3040 ## File substitutions. ##
3041 ## ------------------- ##"
3042 echo
3043 for ac_var in $ac_subst_files
3044 do
3045 eval ac_val=\$$ac_var
3046 case $ac_val in
3047 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3048 esac
3049 $as_echo "$ac_var='\''$ac_val'\''"
3050 done | sort
3051 echo
3052 fi
3053
3054 if test -s confdefs.h; then
3055 $as_echo "## ----------- ##
3056 ## confdefs.h. ##
3057 ## ----------- ##"
3058 echo
3059 cat confdefs.h
3060 echo
3061 fi
3062 test "$ac_signal" != 0 &&
3063 $as_echo "$as_me: caught signal $ac_signal"
3064 $as_echo "$as_me: exit $exit_status"
3065 } >&5
3066 rm -f core *.core core.conftest.* &&
3067 rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3068 exit $exit_status
3069 ' 0
3070 for ac_signal in 1 2 13 15; do
3071 trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3072 done
3073 ac_signal=0
3074
3075 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3076 rm -f -r conftest* confdefs.h
3077
3078 $as_echo "/* confdefs.h */" > confdefs.h
3079
3080 # Predefined preprocessor variables.
3081
3082 cat >>confdefs.h <<_ACEOF
3083 #define PACKAGE_NAME "$PACKAGE_NAME"
3084 _ACEOF
3085
3086 cat >>confdefs.h <<_ACEOF
3087 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3088 _ACEOF
3089
3090 cat >>confdefs.h <<_ACEOF
3091 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3092 _ACEOF
3093
3094 cat >>confdefs.h <<_ACEOF
3095 #define PACKAGE_STRING "$PACKAGE_STRING"
3096 _ACEOF
3097
3098 cat >>confdefs.h <<_ACEOF
3099 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3100 _ACEOF
3101
3102 cat >>confdefs.h <<_ACEOF
3103 #define PACKAGE_URL "$PACKAGE_URL"
3104 _ACEOF
3105
3106
3107 # Let the site file select an alternate cache file if it wants to.
3108 # Prefer an explicitly selected file to automatically selected ones.
3109 ac_site_file1=NONE
3110 ac_site_file2=NONE
3111 if test -n "$CONFIG_SITE"; then
3112 # We do not want a PATH search for config.site.
3113 case $CONFIG_SITE in #((
3114 -*) ac_site_file1=./$CONFIG_SITE;;
3115 */*) ac_site_file1=$CONFIG_SITE;;
3116 *) ac_site_file1=./$CONFIG_SITE;;
3117 esac
3118 elif test "x$prefix" != xNONE; then
3119 ac_site_file1=$prefix/share/config.site
3120 ac_site_file2=$prefix/etc/config.site
3121 else
3122 ac_site_file1=$ac_default_prefix/share/config.site
3123 ac_site_file2=$ac_default_prefix/etc/config.site
3124 fi
3125 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3126 do
3127 test "x$ac_site_file" = xNONE && continue
3128 if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3129 { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3130 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3131 sed 's/^/| /' "$ac_site_file" >&5
3132 . "$ac_site_file" \
3133 || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3134 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3135 as_fn_error $? "failed to load site script $ac_site_file
3136 See \`config.log' for more details" "$LINENO" 5; }
3137 fi
3138 done
3139
3140 if test -r "$cache_file"; then
3141 # Some versions of bash will fail to source /dev/null (special files
3142 # actually), so we avoid doing that. DJGPP emulates it as a regular file.
3143 if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3144 { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3145 $as_echo "$as_me: loading cache $cache_file" >&6;}
3146 case $cache_file in
3147 [\\/]* | ?:[\\/]* ) . "$cache_file";;
3148 *) . "./$cache_file";;
3149 esac
3150 fi
3151 else
3152 { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3153 $as_echo "$as_me: creating cache $cache_file" >&6;}
3154 >$cache_file
3155 fi
3156
3157 # Check that the precious variables saved in the cache have kept the same
3158 # value.
3159 ac_cache_corrupted=false
3160 for ac_var in $ac_precious_vars; do
3161 eval ac_old_set=\$ac_cv_env_${ac_var}_set
3162 eval ac_new_set=\$ac_env_${ac_var}_set
3163 eval ac_old_val=\$ac_cv_env_${ac_var}_value
3164 eval ac_new_val=\$ac_env_${ac_var}_value
3165 case $ac_old_set,$ac_new_set in
3166 set,)
3167 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3168 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3169 ac_cache_corrupted=: ;;
3170 ,set)
3171 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3172 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3173 ac_cache_corrupted=: ;;
3174 ,);;
3175 *)
3176 if test "x$ac_old_val" != "x$ac_new_val"; then
3177 # differences in whitespace do not lead to failure.
3178 ac_old_val_w=`echo x $ac_old_val`
3179 ac_new_val_w=`echo x $ac_new_val`
3180 if test "$ac_old_val_w" != "$ac_new_val_w"; then
3181 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3182 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3183 ac_cache_corrupted=:
3184 else
3185 { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3186 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3187 eval $ac_var=\$ac_old_val
3188 fi
3189 { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
3190 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
3191 { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
3192 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
3193 fi;;
3194 esac
3195 # Pass precious variables to config.status.
3196 if test "$ac_new_set" = set; then
3197 case $ac_new_val in
3198 *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3199 *) ac_arg=$ac_var=$ac_new_val ;;
3200 esac
3201 case " $ac_configure_args " in
3202 *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
3203 *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3204 esac
3205 fi
3206 done
3207 if $ac_cache_corrupted; then
3208 { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3209 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3210 { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3211 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3212 as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3213 fi
3214 ## -------------------- ##
3215 ## Main body of script. ##
3216 ## -------------------- ##
3217
3218 ac_ext=c
3219 ac_cpp='$CPP $CPPFLAGS'
3220 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3221 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3222 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3223
3224
3225
3226 ac_aux_dir=
3227 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3228 if test -f "$ac_dir/install-sh"; then
3229 ac_aux_dir=$ac_dir
3230 ac_install_sh="$ac_aux_dir/install-sh -c"
3231 break
3232 elif test -f "$ac_dir/install.sh"; then
3233 ac_aux_dir=$ac_dir
3234 ac_install_sh="$ac_aux_dir/install.sh -c"
3235 break
3236 elif test -f "$ac_dir/shtool"; then
3237 ac_aux_dir=$ac_dir
3238 ac_install_sh="$ac_aux_dir/shtool install -c"
3239 break
3240 fi
3241 done
3242 if test -z "$ac_aux_dir"; then
3243 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
3244 fi
3245
3246 # These three variables are undocumented and unsupported,
3247 # and are intended to be withdrawn in a future Autoconf release.
3248 # They can cause serious problems if a builder's source tree is in a directory
3249 # whose full name contains unusual characters.
3250 ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
3251 ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
3252 ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
3253
3254
3255 # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
3256
3257 #
3258 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3259 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3260 #
3261 # This code is free software; you can redistribute it and/or modify it
3262 # under the terms of the GNU General Public License version 2 only, as
3263 # published by the Free Software Foundation. Oracle designates this
3264 # particular file as subject to the "Classpath" exception as provided
3265 # by Oracle in the LICENSE file that accompanied this code.
3266 #
3267 # This code is distributed in the hope that it will be useful, but WITHOUT
3268 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3269 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3270 # version 2 for more details (a copy is included in the LICENSE file that
3271 # accompanied this code).
3272 #
3273 # You should have received a copy of the GNU General Public License version
3274 # 2 along with this work; if not, write to the Free Software Foundation,
3275 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3276 #
3277 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3278 # or visit www.oracle.com if you need additional information or have any
3279 # questions.
3280 #
3281
3282 #
3283 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3284 #
3285 # This program is free software; you can redistribute it and/or modify
3286 # it under the terms of the GNU General Public License as published by
3287 # the Free Software Foundation; either version 2 of the License, or
3288 # (at your option) any later version.
3289 #
3290 # This program is distributed in the hope that it will be useful, but
3291 # WITHOUT ANY WARRANTY; without even the implied warranty of
3292 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3293 # General Public License for more details.
3294 #
3295 # You should have received a copy of the GNU General Public License
3296 # along with this program; if not, write to the Free Software
3297 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3298 #
3299 # As a special exception to the GNU General Public License, if you
3300 # distribute this file as part of a program that contains a
3301 # configuration script generated by Autoconf, you may include it under
3302 # the same distribution terms that you use for the rest of that program.
3303
3304 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3305 # ----------------------------------
3306 # PKG_PROG_PKG_CONFIG
3307
3308 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3309 #
3310 # Check to see whether a particular set of modules exists. Similar
3311 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3312 #
3313 #
3314 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3315 # this or PKG_CHECK_MODULES is called, or make sure to call
3316 # PKG_CHECK_EXISTS manually
3317 # --------------------------------------------------------------
3318
3319
3320
3321 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3322 # ---------------------------------------------
3323 # _PKG_CONFIG
3324
3325 # _PKG_SHORT_ERRORS_SUPPORTED
3326 # -----------------------------
3327 # _PKG_SHORT_ERRORS_SUPPORTED
3328
3329
3330 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3331 # [ACTION-IF-NOT-FOUND])
3332 #
3333 #
3334 # Note that if there is a possibility the first call to
3335 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3336 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3337 #
3338 #
3339 # --------------------------------------------------------------
3340 # PKG_CHECK_MODULES
3341
3342
3343 # Include these first...
3344 #
3345 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3346 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3347 #
3348 # This code is free software; you can redistribute it and/or modify it
3349 # under the terms of the GNU General Public License version 2 only, as
3350 # published by the Free Software Foundation. Oracle designates this
3351 # particular file as subject to the "Classpath" exception as provided
3352 # by Oracle in the LICENSE file that accompanied this code.
3353 #
3354 # This code is distributed in the hope that it will be useful, but WITHOUT
3355 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3356 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3357 # version 2 for more details (a copy is included in the LICENSE file that
3358 # accompanied this code).
3359 #
3360 # You should have received a copy of the GNU General Public License version
3361 # 2 along with this work; if not, write to the Free Software Foundation,
3362 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3363 #
3364 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3365 # or visit www.oracle.com if you need additional information or have any
3366 # questions.
3367 #
3368
3369 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3370 # If so, then append $1 to $2 \
3371 # Also set JVM_ARG_OK to true/false depending on outcome.
3372
3373
3374 # Appends a string to a path variable, only adding the : when needed.
3375
3376
3377 # Prepends a string to a path variable, only adding the : when needed.
3378
3379
3380 # This will make sure the given variable points to a full and proper
3381 # path. This means:
3382 # 1) There will be no spaces in the path. On unix platforms,
3383 # spaces in the path will result in an error. On Windows,
3384 # the path will be rewritten using short-style to be space-free.
3385 # 2) The path will be absolute, and it will be in unix-style (on
3386 # cygwin).
3387 # $1: The name of the variable to fix
3388
3389
3390 # This will make sure the given variable points to a executable
3391 # with a full and proper path. This means:
3392 # 1) There will be no spaces in the path. On unix platforms,
3393 # spaces in the path will result in an error. On Windows,
3394 # the path will be rewritten using short-style to be space-free.
3395 # 2) The path will be absolute, and it will be in unix-style (on
3396 # cygwin).
3397 # Any arguments given to the executable is preserved.
3398 # If the input variable does not have a directory specification, then
3399 # it need to be in the PATH.
3400 # $1: The name of the variable to fix
3401
3402
3403
3404
3405 # Register a --with argument but mark it as deprecated
3406 # $1: The name of the with argument to deprecate, not including --with-
3407
3408
3409 # Register a --enable argument but mark it as deprecated
3410 # $1: The name of the with argument to deprecate, not including --enable-
3411 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3412
3413
3414
3415
3416 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3417 # $1: variable to check
3418
3419
3420 # Check that there are no unprocessed overridden variables left.
3421 # If so, they are an incorrect argument and we will exit with an error.
3422
3423
3424 # Setup a tool for the given variable. If correctly specified by the user,
3425 # use that value, otherwise search for the tool using the supplied code snippet.
3426 # $1: variable to set
3427 # $2: code snippet to call to look for the tool
3428
3429
3430 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3431 # $1: variable to set
3432 # $2: executable name (or list of names) to look for
3433
3434
3435 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3436 # $1: variable to set
3437 # $2: executable name (or list of names) to look for
3438
3439
3440 # Like BASIC_PATH_PROGS but fails if no tool was found.
3441 # $1: variable to set
3442 # $2: executable name (or list of names) to look for
3443
3444
3445 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3446 # $1: variable to set
3447 # $2: autoconf macro to call to look for the special tool
3448
3449
3450 # Setup the most fundamental tools that relies on not much else to set up,
3451 # but is used by much of the early bootstrap code.
3452
3453
3454 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464 #%%% Simple tools %%%
3465
3466 # Check if we have found a usable version of make
3467 # $1: the path to a potential make binary (or empty)
3468 # $2: the description on how we found this
3469
3470
3471
3472
3473 # Goes looking for a usable version of GNU make.
3474
3475
3476
3477
3478
3479
3480 # Check if build directory is on local disk. If not possible to determine,
3481 # we prefer to claim it's local.
3482 # Argument 1: directory to test
3483 # Argument 2: what to do if it is on local disk
3484 # Argument 3: what to do otherwise (remote disk or failure)
3485
3486
3487 # Check that source files have basic read permissions set. This might
3488 # not be the case in cygwin in certain conditions.
3489
3490
3491
3492
3493 # Check for support for specific options in bash
3494
3495
3496 #
3497 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3498 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3499 #
3500 # This code is free software; you can redistribute it and/or modify it
3501 # under the terms of the GNU General Public License version 2 only, as
3502 # published by the Free Software Foundation. Oracle designates this
3503 # particular file as subject to the "Classpath" exception as provided
3504 # by Oracle in the LICENSE file that accompanied this code.
3505 #
3506 # This code is distributed in the hope that it will be useful, but WITHOUT
3507 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3508 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3509 # version 2 for more details (a copy is included in the LICENSE file that
3510 # accompanied this code).
3511 #
3512 # You should have received a copy of the GNU General Public License version
3513 # 2 along with this work; if not, write to the Free Software Foundation,
3514 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3515 #
3516 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3517 # or visit www.oracle.com if you need additional information or have any
3518 # questions.
3519 #
3520
3521
3522
3523
3524
3525 # Helper function which possibly converts a path using DOS-style short mode.
3526 # If so, the updated path is stored in $new_path.
3527 # $1: The path to check
3528
3529
3530 # Helper function which possibly converts a path using DOS-style short mode.
3531 # If so, the updated path is stored in $new_path.
3532 # $1: The path to check
3533
3534
3535 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3536 # and could probably be heavily simplified. However, all changes in this
3537 # area tend to need lot of testing in different scenarios, and in lack of
3538 # proper unit testing, cleaning this up has not been deemed worth the effort
3539 # at the moment.
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3550
3551
3552
3553
3554 #
3555 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3556 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3557 #
3558 # This code is free software; you can redistribute it and/or modify it
3559 # under the terms of the GNU General Public License version 2 only, as
3560 # published by the Free Software Foundation. Oracle designates this
3561 # particular file as subject to the "Classpath" exception as provided
3562 # by Oracle in the LICENSE file that accompanied this code.
3563 #
3564 # This code is distributed in the hope that it will be useful, but WITHOUT
3565 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3566 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3567 # version 2 for more details (a copy is included in the LICENSE file that
3568 # accompanied this code).
3569 #
3570 # You should have received a copy of the GNU General Public License version
3571 # 2 along with this work; if not, write to the Free Software Foundation,
3572 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3573 #
3574 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3575 # or visit www.oracle.com if you need additional information or have any
3576 # questions.
3577 #
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589 # ... then the rest
3590 #
3591 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3592 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3593 #
3594 # This code is free software; you can redistribute it and/or modify it
3595 # under the terms of the GNU General Public License version 2 only, as
3596 # published by the Free Software Foundation. Oracle designates this
3597 # particular file as subject to the "Classpath" exception as provided
3598 # by Oracle in the LICENSE file that accompanied this code.
3599 #
3600 # This code is distributed in the hope that it will be useful, but WITHOUT
3601 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3602 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3603 # version 2 for more details (a copy is included in the LICENSE file that
3604 # accompanied this code).
3605 #
3606 # You should have received a copy of the GNU General Public License version
3607 # 2 along with this work; if not, write to the Free Software Foundation,
3608 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3609 #
3610 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3611 # or visit www.oracle.com if you need additional information or have any
3612 # questions.
3613 #
3614
3615 ########################################################################
3616 # This file handles detection of the Boot JDK. The Boot JDK detection
3617 # process has been developed as a response to solve a complex real-world
3618 # problem. Initially, it was simple, but it has grown as platform after
3619 # platform, idiosyncracy after idiosyncracy has been supported.
3620 #
3621 # The basic idea is this:
3622 # 1) You need an acceptable *) JDK to use as a Boot JDK
3623 # 2) There are several ways to locate a JDK, that are mostly platform
3624 # dependent **)
3625 # 3) You can have multiple JDKs installed
3626 # 4) If possible, configure should try to dig out an acceptable JDK
3627 # automatically, without having to resort to command-line options
3628 #
3629 # *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3630 # javac) and not a JRE, etc.
3631 #
3632 # **) On Windows we typically use a well-known path.
3633 # On MacOSX we typically use the tool java_home.
3634 # On Linux we typically find javac in the $PATH, and then follow a
3635 # chain of symlinks that often ends up in a real JDK.
3636 #
3637 # This leads to the code where we check in different ways to locate a
3638 # JDK, and if one is found, check if it is acceptable. If not, we print
3639 # our reasons for rejecting it (useful when debugging non-working
3640 # configure situations) and continue checking the next one.
3641 ########################################################################
3642
3643 # Execute the check given as argument, and verify the result
3644 # If the Boot JDK was previously found, do nothing
3645 # $1 A command line (typically autoconf macro) to execute
3646
3647
3648 # Test: Is bootjdk explicitely set by command line arguments?
3649
3650
3651 # Test: Is bootjdk available from builddeps?
3652
3653
3654 # Test: Is $JAVA_HOME set?
3655
3656
3657 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3658
3659
3660 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3661 # $1: Argument to the java_home binary (optional)
3662
3663
3664 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3665
3666
3667 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3668 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3669 # $1 = Path to directory containing jdk installations.
3670 # $2 = String to append to the found JDK directory to get the proper JDK home
3671
3672
3673 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3674 # environmental variable as base for where to look.
3675 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3676
3677
3678 # Test: Is there a JDK installed in default, well-known locations?
3679
3680
3681 # Check that a command-line tool in the Boot JDK is correct
3682 # $1 = name of variable to assign
3683 # $2 = name of binary
3684
3685
3686 ###############################################################################
3687 #
3688 # We need a Boot JDK to bootstrap the build.
3689 #
3690
3691
3692
3693
3694
3695 #
3696 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3697 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3698 #
3699 # This code is free software; you can redistribute it and/or modify it
3700 # under the terms of the GNU General Public License version 2 only, as
3701 # published by the Free Software Foundation. Oracle designates this
3702 # particular file as subject to the "Classpath" exception as provided
3703 # by Oracle in the LICENSE file that accompanied this code.
3704 #
3705 # This code is distributed in the hope that it will be useful, but WITHOUT
3706 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3707 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3708 # version 2 for more details (a copy is included in the LICENSE file that
3709 # accompanied this code).
3710 #
3711 # You should have received a copy of the GNU General Public License version
3712 # 2 along with this work; if not, write to the Free Software Foundation,
3713 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3714 #
3715 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3716 # or visit www.oracle.com if you need additional information or have any
3717 # questions.
3718 #
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739 #
3740 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3741 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3742 #
3743 # This code is free software; you can redistribute it and/or modify it
3744 # under the terms of the GNU General Public License version 2 only, as
3745 # published by the Free Software Foundation. Oracle designates this
3746 # particular file as subject to the "Classpath" exception as provided
3747 # by Oracle in the LICENSE file that accompanied this code.
3748 #
3749 # This code is distributed in the hope that it will be useful, but WITHOUT
3750 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3751 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3752 # version 2 for more details (a copy is included in the LICENSE file that
3753 # accompanied this code).
3754 #
3755 # You should have received a copy of the GNU General Public License version
3756 # 2 along with this work; if not, write to the Free Software Foundation,
3757 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3758 #
3759 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3760 # or visit www.oracle.com if you need additional information or have any
3761 # questions.
3762 #
3763
3764
3765
3766
3767
3768 # Documentation on common flags used for solstudio in HIGHEST.
3769 #
3770 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3771 # done with care, there are some assumptions below that need to
3772 # be understood about the use of pointers, and IEEE behavior.
3773 #
3774 # -fns: Use non-standard floating point mode (not IEEE 754)
3775 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3776 # -fsingle: Use single precision floating point with 'float'
3777 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3778 # (Source with excessing pointer casting and data access with mixed
3779 # pointer types are not recommended)
3780 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3781 # (If you expect perfect errno behavior, do not use this)
3782 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3783 # -xrestrict: Pointer parameters to functions do not overlap
3784 # (Similar to -xalias_level=basic usage, but less obvious sometimes.
3785 # If you pass in multiple pointers to the same data, do not use this)
3786 # -xlibmil: Inline some library routines
3787 # (If you expect perfect errno behavior, do not use this)
3788 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3789 # (If you expect perfect errno behavior, do not use this)
3790 # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3791
3792 # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3793 # Bug?
3794 #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3795 # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3796 # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3797 #fi
3798
3799
3800
3801
3802
3803 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3804 # [RUN-IF-FALSE])
3805 # ------------------------------------------------------------
3806 # Check that the c and c++ compilers support an argument
3807
3808
3809 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3810 # [RUN-IF-FALSE])
3811 # ------------------------------------------------------------
3812 # Check that the linker support an argument
3813
3814
3815
3816
3817 #
3818 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3819 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3820 #
3821 # This code is free software; you can redistribute it and/or modify it
3822 # under the terms of the GNU General Public License version 2 only, as
3823 # published by the Free Software Foundation. Oracle designates this
3824 # particular file as subject to the "Classpath" exception as provided
3825 # by Oracle in the LICENSE file that accompanied this code.
3826 #
3827 # This code is distributed in the hope that it will be useful, but WITHOUT
3828 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3829 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3830 # version 2 for more details (a copy is included in the LICENSE file that
3831 # accompanied this code).
3832 #
3833 # You should have received a copy of the GNU General Public License version
3834 # 2 along with this work; if not, write to the Free Software Foundation,
3835 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3836 #
3837 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3838 # or visit www.oracle.com if you need additional information or have any
3839 # questions.
3840 #
3841
3842
3843
3844
3845
3846 cygwin_help() {
3847 case $1 in
3848 unzip)
3849 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3850 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3851 ;;
3852 zip)
3853 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3854 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3855 ;;
3856 make)
3857 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3858 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3859 ;;
3860 freetype)
3861 HELP_MSG="
3862 The freetype library can now be build during the configure process.
3863 Download the freetype sources and unpack them into an arbitrary directory:
3864
3865 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3866 tar -xzf freetype-2.5.3.tar.gz
3867
3868 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3869 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3870 builds or into '<freetype_src>/lib32' for 32-bit builds.
3871 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3872 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3873 ;;
3874 esac
3875 }
3876
3877 msys_help() {
3878 PKGHANDLER_COMMAND=""
3879 }
3880
3881 apt_help() {
3882 case $1 in
3883 devkit)
3884 PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3885 openjdk)
3886 PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3887 alsa)
3888 PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3889 cups)
3890 PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3891 freetype)
3892 PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3893 pulse)
3894 PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3895 x11)
3896 PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3897 ccache)
3898 PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3899 esac
3900 }
3901
3902 yum_help() {
3903 case $1 in
3904 devkit)
3905 PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3906 openjdk)
3907 PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3908 alsa)
3909 PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3910 cups)
3911 PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3912 freetype)
3913 PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3914 pulse)
3915 PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3916 x11)
3917 PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3918 ccache)
3919 PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3920 esac
3921 }
3922
3923 port_help() {
3924 PKGHANDLER_COMMAND=""
3925 }
3926
3927 pkgutil_help() {
3928 PKGHANDLER_COMMAND=""
3929 }
3930
3931 pkgadd_help() {
3932 PKGHANDLER_COMMAND=""
3933 }
3934
3935 # This function will check if we're called from the "configure" wrapper while
3936 # printing --help. If so, we will print out additional information that can
3937 # only be extracted within the autoconf script, and then exit. This must be
3938 # called at the very beginning in configure.ac.
3939
3940
3941
3942
3943
3944
3945 #
3946 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3947 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3948 #
3949 # This code is free software; you can redistribute it and/or modify it
3950 # under the terms of the GNU General Public License version 2 only, as
3951 # published by the Free Software Foundation. Oracle designates this
3952 # particular file as subject to the "Classpath" exception as provided
3953 # by Oracle in the LICENSE file that accompanied this code.
3954 #
3955 # This code is distributed in the hope that it will be useful, but WITHOUT
3956 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3957 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3958 # version 2 for more details (a copy is included in the LICENSE file that
3959 # accompanied this code).
3960 #
3961 # You should have received a copy of the GNU General Public License version
3962 # 2 along with this work; if not, write to the Free Software Foundation,
3963 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3964 #
3965 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3966 # or visit www.oracle.com if you need additional information or have any
3967 # questions.
3968 #
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979 ###############################################################################
3980 #
3981 # Should we build only OpenJDK even if closed sources are present?
3982 #
3983
3984
3985
3986
3987 ###############################################################################
3988 #
3989 # Setup version numbers
3990 #
3991
3992
3993
3994
3995
3996
3997 #
3998 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3999 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4000 #
4001 # This code is free software; you can redistribute it and/or modify it
4002 # under the terms of the GNU General Public License version 2 only, as
4003 # published by the Free Software Foundation. Oracle designates this
4004 # particular file as subject to the "Classpath" exception as provided
4005 # by Oracle in the LICENSE file that accompanied this code.
4006 #
4007 # This code is distributed in the hope that it will be useful, but WITHOUT
4008 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4009 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4010 # version 2 for more details (a copy is included in the LICENSE file that
4011 # accompanied this code).
4012 #
4013 # You should have received a copy of the GNU General Public License version
4014 # 2 along with this work; if not, write to the Free Software Foundation,
4015 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4016 #
4017 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4018 # or visit www.oracle.com if you need additional information or have any
4019 # questions.
4020 #
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042 #
4043 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4044 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4045 #
4046 # This code is free software; you can redistribute it and/or modify it
4047 # under the terms of the GNU General Public License version 2 only, as
4048 # published by the Free Software Foundation. Oracle designates this
4049 # particular file as subject to the "Classpath" exception as provided
4050 # by Oracle in the LICENSE file that accompanied this code.
4051 #
4052 # This code is distributed in the hope that it will be useful, but WITHOUT
4053 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4054 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4055 # version 2 for more details (a copy is included in the LICENSE file that
4056 # accompanied this code).
4057 #
4058 # You should have received a copy of the GNU General Public License version
4059 # 2 along with this work; if not, write to the Free Software Foundation,
4060 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4061 #
4062 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4063 # or visit www.oracle.com if you need additional information or have any
4064 # questions.
4065 #
4066
4067 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4068 # Converts autoconf style CPU name to OpenJDK style, into
4069 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4070
4071
4072 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4073 # Converts autoconf style OS name to OpenJDK style, into
4074 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4075
4076
4077 # Expects $host_os $host_cpu $build_os and $build_cpu
4078 # and $with_target_bits to have been setup!
4079 #
4080 # Translate the standard triplet(quadruplet) definition
4081 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4082 # OPENJDK_BUILD_OS, etc.
4083
4084
4085 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4086 # accordingly. Must be done after setting up build and target system, but before
4087 # doing anything else with these values.
4088
4089
4090 # Setup the legacy variables, for controlling the old makefiles.
4091 #
4092
4093
4094
4095
4096 #%%% Build and target systems %%%
4097
4098
4099
4100
4101 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4102 # Add -mX to various FLAGS variables.
4103
4104
4105
4106
4107
4108
4109 #
4110 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4111 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4112 #
4113 # This code is free software; you can redistribute it and/or modify it
4114 # under the terms of the GNU General Public License version 2 only, as
4115 # published by the Free Software Foundation. Oracle designates this
4116 # particular file as subject to the "Classpath" exception as provided
4117 # by Oracle in the LICENSE file that accompanied this code.
4118 #
4119 # This code is distributed in the hope that it will be useful, but WITHOUT
4120 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4121 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4122 # version 2 for more details (a copy is included in the LICENSE file that
4123 # accompanied this code).
4124 #
4125 # You should have received a copy of the GNU General Public License version
4126 # 2 along with this work; if not, write to the Free Software Foundation,
4127 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4128 #
4129 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4130 # or visit www.oracle.com if you need additional information or have any
4131 # questions.
4132 #
4133
4134
4135
4136
4137
4138
4139
4140
4141 #
4142 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4143 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4144 #
4145 # This code is free software; you can redistribute it and/or modify it
4146 # under the terms of the GNU General Public License version 2 only, as
4147 # published by the Free Software Foundation. Oracle designates this
4148 # particular file as subject to the "Classpath" exception as provided
4149 # by Oracle in the LICENSE file that accompanied this code.
4150 #
4151 # This code is distributed in the hope that it will be useful, but WITHOUT
4152 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4153 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4154 # version 2 for more details (a copy is included in the LICENSE file that
4155 # accompanied this code).
4156 #
4157 # You should have received a copy of the GNU General Public License version
4158 # 2 along with this work; if not, write to the Free Software Foundation,
4159 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4160 #
4161 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4162 # or visit www.oracle.com if you need additional information or have any
4163 # questions.
4164 #
4165
4166 ########################################################################
4167 # This file is responsible for detecting, verifying and setting up the
4168 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4169 # proper paths to the binaries, but it will not setup any flags.
4170 #
4171 # The binaries used is determined by the toolchain type, which is the family of
4172 # compilers and related tools that are used.
4173 ########################################################################
4174
4175
4176 # All valid toolchains, regardless of platform (used by help.m4)
4177 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4178
4179 # These toolchains are valid on different platforms
4180 VALID_TOOLCHAINS_linux="gcc clang"
4181 VALID_TOOLCHAINS_solaris="solstudio"
4182 VALID_TOOLCHAINS_macosx="gcc clang"
4183 VALID_TOOLCHAINS_aix="xlc"
4184 VALID_TOOLCHAINS_windows="microsoft"
4185
4186 # Toolchain descriptions
4187 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4188 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4189 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4190 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4191 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4192
4193 # Setup a number of variables describing how native output files are
4194 # named on this platform/toolchain.
4195
4196
4197 # Determine which toolchain type to use, and make sure it is valid for this
4198 # platform. Setup various information about the selected toolchain.
4199
4200
4201 # Before we start detecting the toolchain executables, we might need some
4202 # special setup, e.g. additional paths etc.
4203
4204
4205 # Restore path, etc
4206
4207
4208 # Check if a compiler is of the toolchain type we expect, and save the version
4209 # information from it. If the compiler does not match the expected type,
4210 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4211 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4212 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4213 #
4214 # $1 = compiler to test (CC or CXX)
4215 # $2 = human readable name of compiler (C or C++)
4216
4217
4218 # Try to locate the given C or C++ compiler in the path, or otherwise.
4219 #
4220 # $1 = compiler to test (CC or CXX)
4221 # $2 = human readable name of compiler (C or C++)
4222 # $3 = list of compiler names to search for
4223
4224
4225 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4226 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4227 # archiver (AR). Verify that the compilers are correct according to the
4228 # toolchain type.
4229
4230
4231 # Setup additional tools that is considered a part of the toolchain, but not the
4232 # core part. Many of these are highly platform-specific and do not exist,
4233 # and/or are not needed on all platforms.
4234
4235
4236 # Setup the build tools (i.e, the compiler and linker used to build programs
4237 # that should be run on the build platform, not the target platform, as a build
4238 # helper). Since the non-cross-compile case uses the normal, target compilers
4239 # for this, we can only do this after these have been setup.
4240
4241
4242 # Setup legacy variables that are still needed as alternative ways to refer to
4243 # parts of the toolchain.
4244
4245
4246 # Do some additional checks on the detected tools.
4247
4248
4249 # Setup the JTReg Regression Test Harness.
4250
4251
4252 #
4253 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4254 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4255 #
4256 # This code is free software; you can redistribute it and/or modify it
4257 # under the terms of the GNU General Public License version 2 only, as
4258 # published by the Free Software Foundation. Oracle designates this
4259 # particular file as subject to the "Classpath" exception as provided
4260 # by Oracle in the LICENSE file that accompanied this code.
4261 #
4262 # This code is distributed in the hope that it will be useful, but WITHOUT
4263 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4264 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4265 # version 2 for more details (a copy is included in the LICENSE file that
4266 # accompanied this code).
4267 #
4268 # You should have received a copy of the GNU General Public License version
4269 # 2 along with this work; if not, write to the Free Software Foundation,
4270 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4271 #
4272 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4273 # or visit www.oracle.com if you need additional information or have any
4274 # questions.
4275 #
4276
4277 ################################################################################
4278
4279 VALID_VS_VERSIONS="2010 2012 2013"
4280
4281 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4282 VS_VERSION_INTERNAL_2010=100
4283 VS_MSVCR_2010=msvcr100.dll
4284 # We don't use msvcp on Visual Studio 2010
4285 #VS_MSVCP_2010=msvcp100.dll
4286 VS_ENVVAR_2010="VS100COMNTOOLS"
4287 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4288 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4289 VS_VS_PLATFORM_NAME_2010="v100"
4290 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4291
4292 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4293 VS_VERSION_INTERNAL_2012=110
4294 VS_MSVCR_2012=msvcr110.dll
4295 VS_MSVCP_2012=msvcp110.dll
4296 VS_ENVVAR_2012="VS110COMNTOOLS"
4297 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4298 VS_SDK_INSTALLDIR_2012=
4299 VS_VS_PLATFORM_NAME_2012="v110"
4300 VS_SDK_PLATFORM_NAME_2012=
4301
4302 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4303 VS_VERSION_INTERNAL_2013=120
4304 VS_MSVCR_2013=msvcr120.dll
4305 VS_MSVCP_2013=msvcp120.dll
4306 VS_ENVVAR_2013="VS120COMNTOOLS"
4307 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4308 VS_SDK_INSTALLDIR_2013=
4309 VS_VS_PLATFORM_NAME_2013="v120"
4310 VS_SDK_PLATFORM_NAME_2013=
4311
4312 ################################################################################
4313
4314
4315
4316 ################################################################################
4317
4318
4319
4320 ################################################################################
4321 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4322 # build environment and assigns it to VS_ENV_CMD
4323
4324
4325 ################################################################################
4326
4327
4328
4329 ################################################################################
4330 # Check if the VS env variables were setup prior to running configure.
4331 # If not, then find vcvarsall.bat and run it automatically, and integrate
4332 # the set env variables into the spec file.
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346 # This line needs to be here, verbatim, after all includes and the dummy hook
4347 # definitions. It is replaced with custom functionality when building
4348 # custom sources.
4349 #CUSTOM_AUTOCONF_INCLUDE
4350
4351 # Do not change or remove the following line, it is needed for consistency checks:
4352 DATE_WHEN_GENERATED=1425658225
4353
4354 ###############################################################################
4355 #
4356 # Initialization / Boot-strapping
4357 #
4358 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4359 # thus it jumps back and forth, each time gaining something needed later on.
4360 #
4361 ###############################################################################
4362
4363 # If we are requested to print additional help, do that and then exit.
4364 # This must be the very first call.
4365
4366 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4367 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4368 $PRINTF "Which are valid to use depends on the build platform.\n"
4369 for toolchain in $VALID_TOOLCHAINS_all; do
4370 # Use indirect variable referencing
4371 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4372 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4373 $PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4374 done
4375
4376 # And now exit directly
4377 exit 0
4378 fi
4379
4380
4381 # Basic initialization that must happen first of all in the normal process.
4382
4383 # Save the original command line. This is passed to us by the wrapper configure script.
4384
4385 # Save the path variable before it gets changed
4386 ORIGINAL_PATH="$PATH"
4387
4388 DATE_WHEN_CONFIGURED=`LANG=C date`
4389
4390 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4391 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4392 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4393 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4394
4395
4396 # Start with tools that do not need have cross compilation support
4397 # and can be expected to be found in the default PATH. These tools are
4398 # used by configure. Nor are these tools expected to be found in the
4399 # devkit from the builddeps server either, since they are
4400 # needed to download the devkit.
4401
4402 # First are all the simple required tools.
4403
4404
4405
4406 # Publish this variable in the help.
4407
4408
4409 if test "x$BASENAME" = x; then
4410 # The variable is not set by user, try to locate tool using the code snippet
4411 for ac_prog in basename
4412 do
4413 # Extract the first word of "$ac_prog", so it can be a program name with args.
4414 set dummy $ac_prog; ac_word=$2
4415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4416 $as_echo_n "checking for $ac_word... " >&6; }
4417 if ${ac_cv_path_BASENAME+:} false; then :
4418 $as_echo_n "(cached) " >&6
4419 else
4420 case $BASENAME in
4421 [\\/]* | ?:[\\/]*)
4422 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4423 ;;
4424 *)
4425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4426 for as_dir in $PATH
4427 do
4428 IFS=$as_save_IFS
4429 test -z "$as_dir" && as_dir=.
4430 for ac_exec_ext in '' $ac_executable_extensions; do
4431 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4432 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4433 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4434 break 2
4435 fi
4436 done
4437 done
4438 IFS=$as_save_IFS
4439
4440 ;;
4441 esac
4442 fi
4443 BASENAME=$ac_cv_path_BASENAME
4444 if test -n "$BASENAME"; then
4445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4446 $as_echo "$BASENAME" >&6; }
4447 else
4448 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4449 $as_echo "no" >&6; }
4450 fi
4451
4452
4453 test -n "$BASENAME" && break
4454 done
4455
4456 else
4457 # The variable is set, but is it from the command line or the environment?
4458
4459 # Try to remove the string !BASENAME! from our list.
4460 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4461 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4462 # If it failed, the variable was not from the command line. Ignore it,
4463 # but warn the user (except for BASH, which is always set by the calling BASH).
4464 if test "xBASENAME" != xBASH; then
4465 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4466 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4467 fi
4468 # Try to locate tool using the code snippet
4469 for ac_prog in basename
4470 do
4471 # Extract the first word of "$ac_prog", so it can be a program name with args.
4472 set dummy $ac_prog; ac_word=$2
4473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4474 $as_echo_n "checking for $ac_word... " >&6; }
4475 if ${ac_cv_path_BASENAME+:} false; then :
4476 $as_echo_n "(cached) " >&6
4477 else
4478 case $BASENAME in
4479 [\\/]* | ?:[\\/]*)
4480 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4481 ;;
4482 *)
4483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4484 for as_dir in $PATH
4485 do
4486 IFS=$as_save_IFS
4487 test -z "$as_dir" && as_dir=.
4488 for ac_exec_ext in '' $ac_executable_extensions; do
4489 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4490 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4491 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4492 break 2
4493 fi
4494 done
4495 done
4496 IFS=$as_save_IFS
4497
4498 ;;
4499 esac
4500 fi
4501 BASENAME=$ac_cv_path_BASENAME
4502 if test -n "$BASENAME"; then
4503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4504 $as_echo "$BASENAME" >&6; }
4505 else
4506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4507 $as_echo "no" >&6; }
4508 fi
4509
4510
4511 test -n "$BASENAME" && break
4512 done
4513
4514 else
4515 # If it succeeded, then it was overridden by the user. We will use it
4516 # for the tool.
4517
4518 # First remove it from the list of overridden variables, so we can test
4519 # for unknown variables in the end.
4520 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4521
4522 # Check if the provided tool contains a complete path.
4523 tool_specified="$BASENAME"
4524 tool_basename="${tool_specified##*/}"
4525 if test "x$tool_basename" = "x$tool_specified"; then
4526 # A command without a complete path is provided, search $PATH.
4527 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4528 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4529 # Extract the first word of "$tool_basename", so it can be a program name with args.
4530 set dummy $tool_basename; ac_word=$2
4531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4532 $as_echo_n "checking for $ac_word... " >&6; }
4533 if ${ac_cv_path_BASENAME+:} false; then :
4534 $as_echo_n "(cached) " >&6
4535 else
4536 case $BASENAME in
4537 [\\/]* | ?:[\\/]*)
4538 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4539 ;;
4540 *)
4541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4542 for as_dir in $PATH
4543 do
4544 IFS=$as_save_IFS
4545 test -z "$as_dir" && as_dir=.
4546 for ac_exec_ext in '' $ac_executable_extensions; do
4547 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4548 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4549 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4550 break 2
4551 fi
4552 done
4553 done
4554 IFS=$as_save_IFS
4555
4556 ;;
4557 esac
4558 fi
4559 BASENAME=$ac_cv_path_BASENAME
4560 if test -n "$BASENAME"; then
4561 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4562 $as_echo "$BASENAME" >&6; }
4563 else
4564 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4565 $as_echo "no" >&6; }
4566 fi
4567
4568
4569 if test "x$BASENAME" = x; then
4570 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4571 fi
4572 else
4573 # Otherwise we believe it is a complete path. Use it as it is.
4574 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4575 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4577 $as_echo_n "checking for BASENAME... " >&6; }
4578 if test ! -x "$tool_specified"; then
4579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4580 $as_echo "not found" >&6; }
4581 as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4582 fi
4583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4584 $as_echo "$tool_specified" >&6; }
4585 fi
4586 fi
4587 fi
4588
4589
4590
4591 if test "x$BASENAME" = x; then
4592 as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4593 fi
4594
4595
4596
4597
4598
4599 # Publish this variable in the help.
4600
4601
4602 if test "x$BASH" = x; then
4603 # The variable is not set by user, try to locate tool using the code snippet
4604 for ac_prog in bash
4605 do
4606 # Extract the first word of "$ac_prog", so it can be a program name with args.
4607 set dummy $ac_prog; ac_word=$2
4608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4609 $as_echo_n "checking for $ac_word... " >&6; }
4610 if ${ac_cv_path_BASH+:} false; then :
4611 $as_echo_n "(cached) " >&6
4612 else
4613 case $BASH in
4614 [\\/]* | ?:[\\/]*)
4615 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4616 ;;
4617 *)
4618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4619 for as_dir in $PATH
4620 do
4621 IFS=$as_save_IFS
4622 test -z "$as_dir" && as_dir=.
4623 for ac_exec_ext in '' $ac_executable_extensions; do
4624 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4625 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4626 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4627 break 2
4628 fi
4629 done
4630 done
4631 IFS=$as_save_IFS
4632
4633 ;;
4634 esac
4635 fi
4636 BASH=$ac_cv_path_BASH
4637 if test -n "$BASH"; then
4638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4639 $as_echo "$BASH" >&6; }
4640 else
4641 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4642 $as_echo "no" >&6; }
4643 fi
4644
4645
4646 test -n "$BASH" && break
4647 done
4648
4649 else
4650 # The variable is set, but is it from the command line or the environment?
4651
4652 # Try to remove the string !BASH! from our list.
4653 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4654 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4655 # If it failed, the variable was not from the command line. Ignore it,
4656 # but warn the user (except for BASH, which is always set by the calling BASH).
4657 if test "xBASH" != xBASH; then
4658 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4659 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4660 fi
4661 # Try to locate tool using the code snippet
4662 for ac_prog in bash
4663 do
4664 # Extract the first word of "$ac_prog", so it can be a program name with args.
4665 set dummy $ac_prog; ac_word=$2
4666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4667 $as_echo_n "checking for $ac_word... " >&6; }
4668 if ${ac_cv_path_BASH+:} false; then :
4669 $as_echo_n "(cached) " >&6
4670 else
4671 case $BASH in
4672 [\\/]* | ?:[\\/]*)
4673 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4674 ;;
4675 *)
4676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4677 for as_dir in $PATH
4678 do
4679 IFS=$as_save_IFS
4680 test -z "$as_dir" && as_dir=.
4681 for ac_exec_ext in '' $ac_executable_extensions; do
4682 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4683 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4684 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4685 break 2
4686 fi
4687 done
4688 done
4689 IFS=$as_save_IFS
4690
4691 ;;
4692 esac
4693 fi
4694 BASH=$ac_cv_path_BASH
4695 if test -n "$BASH"; then
4696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4697 $as_echo "$BASH" >&6; }
4698 else
4699 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4700 $as_echo "no" >&6; }
4701 fi
4702
4703
4704 test -n "$BASH" && break
4705 done
4706
4707 else
4708 # If it succeeded, then it was overridden by the user. We will use it
4709 # for the tool.
4710
4711 # First remove it from the list of overridden variables, so we can test
4712 # for unknown variables in the end.
4713 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4714
4715 # Check if the provided tool contains a complete path.
4716 tool_specified="$BASH"
4717 tool_basename="${tool_specified##*/}"
4718 if test "x$tool_basename" = "x$tool_specified"; then
4719 # A command without a complete path is provided, search $PATH.
4720 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4721 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4722 # Extract the first word of "$tool_basename", so it can be a program name with args.
4723 set dummy $tool_basename; ac_word=$2
4724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4725 $as_echo_n "checking for $ac_word... " >&6; }
4726 if ${ac_cv_path_BASH+:} false; then :
4727 $as_echo_n "(cached) " >&6
4728 else
4729 case $BASH in
4730 [\\/]* | ?:[\\/]*)
4731 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4732 ;;
4733 *)
4734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4735 for as_dir in $PATH
4736 do
4737 IFS=$as_save_IFS
4738 test -z "$as_dir" && as_dir=.
4739 for ac_exec_ext in '' $ac_executable_extensions; do
4740 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4741 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4742 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4743 break 2
4744 fi
4745 done
4746 done
4747 IFS=$as_save_IFS
4748
4749 ;;
4750 esac
4751 fi
4752 BASH=$ac_cv_path_BASH
4753 if test -n "$BASH"; then
4754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4755 $as_echo "$BASH" >&6; }
4756 else
4757 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4758 $as_echo "no" >&6; }
4759 fi
4760
4761
4762 if test "x$BASH" = x; then
4763 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4764 fi
4765 else
4766 # Otherwise we believe it is a complete path. Use it as it is.
4767 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4768 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4769 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4770 $as_echo_n "checking for BASH... " >&6; }
4771 if test ! -x "$tool_specified"; then
4772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4773 $as_echo "not found" >&6; }
4774 as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4775 fi
4776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4777 $as_echo "$tool_specified" >&6; }
4778 fi
4779 fi
4780 fi
4781
4782
4783
4784 if test "x$BASH" = x; then
4785 as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4786 fi
4787
4788
4789
4790
4791
4792 # Publish this variable in the help.
4793
4794
4795 if test "x$CAT" = x; then
4796 # The variable is not set by user, try to locate tool using the code snippet
4797 for ac_prog in cat
4798 do
4799 # Extract the first word of "$ac_prog", so it can be a program name with args.
4800 set dummy $ac_prog; ac_word=$2
4801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4802 $as_echo_n "checking for $ac_word... " >&6; }
4803 if ${ac_cv_path_CAT+:} false; then :
4804 $as_echo_n "(cached) " >&6
4805 else
4806 case $CAT in
4807 [\\/]* | ?:[\\/]*)
4808 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4809 ;;
4810 *)
4811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4812 for as_dir in $PATH
4813 do
4814 IFS=$as_save_IFS
4815 test -z "$as_dir" && as_dir=.
4816 for ac_exec_ext in '' $ac_executable_extensions; do
4817 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4818 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4819 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4820 break 2
4821 fi
4822 done
4823 done
4824 IFS=$as_save_IFS
4825
4826 ;;
4827 esac
4828 fi
4829 CAT=$ac_cv_path_CAT
4830 if test -n "$CAT"; then
4831 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4832 $as_echo "$CAT" >&6; }
4833 else
4834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4835 $as_echo "no" >&6; }
4836 fi
4837
4838
4839 test -n "$CAT" && break
4840 done
4841
4842 else
4843 # The variable is set, but is it from the command line or the environment?
4844
4845 # Try to remove the string !CAT! from our list.
4846 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4847 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4848 # If it failed, the variable was not from the command line. Ignore it,
4849 # but warn the user (except for BASH, which is always set by the calling BASH).
4850 if test "xCAT" != xBASH; then
4851 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4852 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4853 fi
4854 # Try to locate tool using the code snippet
4855 for ac_prog in cat
4856 do
4857 # Extract the first word of "$ac_prog", so it can be a program name with args.
4858 set dummy $ac_prog; ac_word=$2
4859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4860 $as_echo_n "checking for $ac_word... " >&6; }
4861 if ${ac_cv_path_CAT+:} false; then :
4862 $as_echo_n "(cached) " >&6
4863 else
4864 case $CAT in
4865 [\\/]* | ?:[\\/]*)
4866 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4867 ;;
4868 *)
4869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4870 for as_dir in $PATH
4871 do
4872 IFS=$as_save_IFS
4873 test -z "$as_dir" && as_dir=.
4874 for ac_exec_ext in '' $ac_executable_extensions; do
4875 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4876 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4877 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4878 break 2
4879 fi
4880 done
4881 done
4882 IFS=$as_save_IFS
4883
4884 ;;
4885 esac
4886 fi
4887 CAT=$ac_cv_path_CAT
4888 if test -n "$CAT"; then
4889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4890 $as_echo "$CAT" >&6; }
4891 else
4892 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4893 $as_echo "no" >&6; }
4894 fi
4895
4896
4897 test -n "$CAT" && break
4898 done
4899
4900 else
4901 # If it succeeded, then it was overridden by the user. We will use it
4902 # for the tool.
4903
4904 # First remove it from the list of overridden variables, so we can test
4905 # for unknown variables in the end.
4906 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4907
4908 # Check if the provided tool contains a complete path.
4909 tool_specified="$CAT"
4910 tool_basename="${tool_specified##*/}"
4911 if test "x$tool_basename" = "x$tool_specified"; then
4912 # A command without a complete path is provided, search $PATH.
4913 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4914 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4915 # Extract the first word of "$tool_basename", so it can be a program name with args.
4916 set dummy $tool_basename; ac_word=$2
4917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4918 $as_echo_n "checking for $ac_word... " >&6; }
4919 if ${ac_cv_path_CAT+:} false; then :
4920 $as_echo_n "(cached) " >&6
4921 else
4922 case $CAT in
4923 [\\/]* | ?:[\\/]*)
4924 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4925 ;;
4926 *)
4927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4928 for as_dir in $PATH
4929 do
4930 IFS=$as_save_IFS
4931 test -z "$as_dir" && as_dir=.
4932 for ac_exec_ext in '' $ac_executable_extensions; do
4933 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4934 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4935 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4936 break 2
4937 fi
4938 done
4939 done
4940 IFS=$as_save_IFS
4941
4942 ;;
4943 esac
4944 fi
4945 CAT=$ac_cv_path_CAT
4946 if test -n "$CAT"; then
4947 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4948 $as_echo "$CAT" >&6; }
4949 else
4950 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4951 $as_echo "no" >&6; }
4952 fi
4953
4954
4955 if test "x$CAT" = x; then
4956 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4957 fi
4958 else
4959 # Otherwise we believe it is a complete path. Use it as it is.
4960 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4961 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4963 $as_echo_n "checking for CAT... " >&6; }
4964 if test ! -x "$tool_specified"; then
4965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4966 $as_echo "not found" >&6; }
4967 as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4968 fi
4969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4970 $as_echo "$tool_specified" >&6; }
4971 fi
4972 fi
4973 fi
4974
4975
4976
4977 if test "x$CAT" = x; then
4978 as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4979 fi
4980
4981
4982
4983
4984
4985 # Publish this variable in the help.
4986
4987
4988 if test "x$CHMOD" = x; then
4989 # The variable is not set by user, try to locate tool using the code snippet
4990 for ac_prog in chmod
4991 do
4992 # Extract the first word of "$ac_prog", so it can be a program name with args.
4993 set dummy $ac_prog; ac_word=$2
4994 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4995 $as_echo_n "checking for $ac_word... " >&6; }
4996 if ${ac_cv_path_CHMOD+:} false; then :
4997 $as_echo_n "(cached) " >&6
4998 else
4999 case $CHMOD in
5000 [\\/]* | ?:[\\/]*)
5001 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5002 ;;
5003 *)
5004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5005 for as_dir in $PATH
5006 do
5007 IFS=$as_save_IFS
5008 test -z "$as_dir" && as_dir=.
5009 for ac_exec_ext in '' $ac_executable_extensions; do
5010 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5011 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5012 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5013 break 2
5014 fi
5015 done
5016 done
5017 IFS=$as_save_IFS
5018
5019 ;;
5020 esac
5021 fi
5022 CHMOD=$ac_cv_path_CHMOD
5023 if test -n "$CHMOD"; then
5024 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5025 $as_echo "$CHMOD" >&6; }
5026 else
5027 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5028 $as_echo "no" >&6; }
5029 fi
5030
5031
5032 test -n "$CHMOD" && break
5033 done
5034
5035 else
5036 # The variable is set, but is it from the command line or the environment?
5037
5038 # Try to remove the string !CHMOD! from our list.
5039 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5040 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5041 # If it failed, the variable was not from the command line. Ignore it,
5042 # but warn the user (except for BASH, which is always set by the calling BASH).
5043 if test "xCHMOD" != xBASH; then
5044 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5045 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5046 fi
5047 # Try to locate tool using the code snippet
5048 for ac_prog in chmod
5049 do
5050 # Extract the first word of "$ac_prog", so it can be a program name with args.
5051 set dummy $ac_prog; ac_word=$2
5052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5053 $as_echo_n "checking for $ac_word... " >&6; }
5054 if ${ac_cv_path_CHMOD+:} false; then :
5055 $as_echo_n "(cached) " >&6
5056 else
5057 case $CHMOD in
5058 [\\/]* | ?:[\\/]*)
5059 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5060 ;;
5061 *)
5062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5063 for as_dir in $PATH
5064 do
5065 IFS=$as_save_IFS
5066 test -z "$as_dir" && as_dir=.
5067 for ac_exec_ext in '' $ac_executable_extensions; do
5068 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5069 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5070 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5071 break 2
5072 fi
5073 done
5074 done
5075 IFS=$as_save_IFS
5076
5077 ;;
5078 esac
5079 fi
5080 CHMOD=$ac_cv_path_CHMOD
5081 if test -n "$CHMOD"; then
5082 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5083 $as_echo "$CHMOD" >&6; }
5084 else
5085 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5086 $as_echo "no" >&6; }
5087 fi
5088
5089
5090 test -n "$CHMOD" && break
5091 done
5092
5093 else
5094 # If it succeeded, then it was overridden by the user. We will use it
5095 # for the tool.
5096
5097 # First remove it from the list of overridden variables, so we can test
5098 # for unknown variables in the end.
5099 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5100
5101 # Check if the provided tool contains a complete path.
5102 tool_specified="$CHMOD"
5103 tool_basename="${tool_specified##*/}"
5104 if test "x$tool_basename" = "x$tool_specified"; then
5105 # A command without a complete path is provided, search $PATH.
5106 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5107 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5108 # Extract the first word of "$tool_basename", so it can be a program name with args.
5109 set dummy $tool_basename; ac_word=$2
5110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5111 $as_echo_n "checking for $ac_word... " >&6; }
5112 if ${ac_cv_path_CHMOD+:} false; then :
5113 $as_echo_n "(cached) " >&6
5114 else
5115 case $CHMOD in
5116 [\\/]* | ?:[\\/]*)
5117 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5118 ;;
5119 *)
5120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5121 for as_dir in $PATH
5122 do
5123 IFS=$as_save_IFS
5124 test -z "$as_dir" && as_dir=.
5125 for ac_exec_ext in '' $ac_executable_extensions; do
5126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5127 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5129 break 2
5130 fi
5131 done
5132 done
5133 IFS=$as_save_IFS
5134
5135 ;;
5136 esac
5137 fi
5138 CHMOD=$ac_cv_path_CHMOD
5139 if test -n "$CHMOD"; then
5140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5141 $as_echo "$CHMOD" >&6; }
5142 else
5143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5144 $as_echo "no" >&6; }
5145 fi
5146
5147
5148 if test "x$CHMOD" = x; then
5149 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5150 fi
5151 else
5152 # Otherwise we believe it is a complete path. Use it as it is.
5153 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5154 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5156 $as_echo_n "checking for CHMOD... " >&6; }
5157 if test ! -x "$tool_specified"; then
5158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5159 $as_echo "not found" >&6; }
5160 as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5161 fi
5162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5163 $as_echo "$tool_specified" >&6; }
5164 fi
5165 fi
5166 fi
5167
5168
5169
5170 if test "x$CHMOD" = x; then
5171 as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5172 fi
5173
5174
5175
5176
5177
5178 # Publish this variable in the help.
5179
5180
5181 if test "x$CMP" = x; then
5182 # The variable is not set by user, try to locate tool using the code snippet
5183 for ac_prog in cmp
5184 do
5185 # Extract the first word of "$ac_prog", so it can be a program name with args.
5186 set dummy $ac_prog; ac_word=$2
5187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5188 $as_echo_n "checking for $ac_word... " >&6; }
5189 if ${ac_cv_path_CMP+:} false; then :
5190 $as_echo_n "(cached) " >&6
5191 else
5192 case $CMP in
5193 [\\/]* | ?:[\\/]*)
5194 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5195 ;;
5196 *)
5197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5198 for as_dir in $PATH
5199 do
5200 IFS=$as_save_IFS
5201 test -z "$as_dir" && as_dir=.
5202 for ac_exec_ext in '' $ac_executable_extensions; do
5203 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5204 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5205 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5206 break 2
5207 fi
5208 done
5209 done
5210 IFS=$as_save_IFS
5211
5212 ;;
5213 esac
5214 fi
5215 CMP=$ac_cv_path_CMP
5216 if test -n "$CMP"; then
5217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5218 $as_echo "$CMP" >&6; }
5219 else
5220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5221 $as_echo "no" >&6; }
5222 fi
5223
5224
5225 test -n "$CMP" && break
5226 done
5227
5228 else
5229 # The variable is set, but is it from the command line or the environment?
5230
5231 # Try to remove the string !CMP! from our list.
5232 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5233 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5234 # If it failed, the variable was not from the command line. Ignore it,
5235 # but warn the user (except for BASH, which is always set by the calling BASH).
5236 if test "xCMP" != xBASH; then
5237 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5238 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5239 fi
5240 # Try to locate tool using the code snippet
5241 for ac_prog in cmp
5242 do
5243 # Extract the first word of "$ac_prog", so it can be a program name with args.
5244 set dummy $ac_prog; ac_word=$2
5245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5246 $as_echo_n "checking for $ac_word... " >&6; }
5247 if ${ac_cv_path_CMP+:} false; then :
5248 $as_echo_n "(cached) " >&6
5249 else
5250 case $CMP in
5251 [\\/]* | ?:[\\/]*)
5252 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5253 ;;
5254 *)
5255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5256 for as_dir in $PATH
5257 do
5258 IFS=$as_save_IFS
5259 test -z "$as_dir" && as_dir=.
5260 for ac_exec_ext in '' $ac_executable_extensions; do
5261 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5262 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5263 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5264 break 2
5265 fi
5266 done
5267 done
5268 IFS=$as_save_IFS
5269
5270 ;;
5271 esac
5272 fi
5273 CMP=$ac_cv_path_CMP
5274 if test -n "$CMP"; then
5275 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5276 $as_echo "$CMP" >&6; }
5277 else
5278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5279 $as_echo "no" >&6; }
5280 fi
5281
5282
5283 test -n "$CMP" && break
5284 done
5285
5286 else
5287 # If it succeeded, then it was overridden by the user. We will use it
5288 # for the tool.
5289
5290 # First remove it from the list of overridden variables, so we can test
5291 # for unknown variables in the end.
5292 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5293
5294 # Check if the provided tool contains a complete path.
5295 tool_specified="$CMP"
5296 tool_basename="${tool_specified##*/}"
5297 if test "x$tool_basename" = "x$tool_specified"; then
5298 # A command without a complete path is provided, search $PATH.
5299 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5300 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5301 # Extract the first word of "$tool_basename", so it can be a program name with args.
5302 set dummy $tool_basename; ac_word=$2
5303 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5304 $as_echo_n "checking for $ac_word... " >&6; }
5305 if ${ac_cv_path_CMP+:} false; then :
5306 $as_echo_n "(cached) " >&6
5307 else
5308 case $CMP in
5309 [\\/]* | ?:[\\/]*)
5310 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5311 ;;
5312 *)
5313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5314 for as_dir in $PATH
5315 do
5316 IFS=$as_save_IFS
5317 test -z "$as_dir" && as_dir=.
5318 for ac_exec_ext in '' $ac_executable_extensions; do
5319 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5320 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5321 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5322 break 2
5323 fi
5324 done
5325 done
5326 IFS=$as_save_IFS
5327
5328 ;;
5329 esac
5330 fi
5331 CMP=$ac_cv_path_CMP
5332 if test -n "$CMP"; then
5333 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5334 $as_echo "$CMP" >&6; }
5335 else
5336 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5337 $as_echo "no" >&6; }
5338 fi
5339
5340
5341 if test "x$CMP" = x; then
5342 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5343 fi
5344 else
5345 # Otherwise we believe it is a complete path. Use it as it is.
5346 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5347 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5349 $as_echo_n "checking for CMP... " >&6; }
5350 if test ! -x "$tool_specified"; then
5351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5352 $as_echo "not found" >&6; }
5353 as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5354 fi
5355 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5356 $as_echo "$tool_specified" >&6; }
5357 fi
5358 fi
5359 fi
5360
5361
5362
5363 if test "x$CMP" = x; then
5364 as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5365 fi
5366
5367
5368
5369
5370
5371 # Publish this variable in the help.
5372
5373
5374 if test "x$COMM" = x; then
5375 # The variable is not set by user, try to locate tool using the code snippet
5376 for ac_prog in comm
5377 do
5378 # Extract the first word of "$ac_prog", so it can be a program name with args.
5379 set dummy $ac_prog; ac_word=$2
5380 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5381 $as_echo_n "checking for $ac_word... " >&6; }
5382 if ${ac_cv_path_COMM+:} false; then :
5383 $as_echo_n "(cached) " >&6
5384 else
5385 case $COMM in
5386 [\\/]* | ?:[\\/]*)
5387 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5388 ;;
5389 *)
5390 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5391 for as_dir in $PATH
5392 do
5393 IFS=$as_save_IFS
5394 test -z "$as_dir" && as_dir=.
5395 for ac_exec_ext in '' $ac_executable_extensions; do
5396 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5397 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5398 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5399 break 2
5400 fi
5401 done
5402 done
5403 IFS=$as_save_IFS
5404
5405 ;;
5406 esac
5407 fi
5408 COMM=$ac_cv_path_COMM
5409 if test -n "$COMM"; then
5410 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5411 $as_echo "$COMM" >&6; }
5412 else
5413 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5414 $as_echo "no" >&6; }
5415 fi
5416
5417
5418 test -n "$COMM" && break
5419 done
5420
5421 else
5422 # The variable is set, but is it from the command line or the environment?
5423
5424 # Try to remove the string !COMM! from our list.
5425 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5426 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5427 # If it failed, the variable was not from the command line. Ignore it,
5428 # but warn the user (except for BASH, which is always set by the calling BASH).
5429 if test "xCOMM" != xBASH; then
5430 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5431 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5432 fi
5433 # Try to locate tool using the code snippet
5434 for ac_prog in comm
5435 do
5436 # Extract the first word of "$ac_prog", so it can be a program name with args.
5437 set dummy $ac_prog; ac_word=$2
5438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5439 $as_echo_n "checking for $ac_word... " >&6; }
5440 if ${ac_cv_path_COMM+:} false; then :
5441 $as_echo_n "(cached) " >&6
5442 else
5443 case $COMM in
5444 [\\/]* | ?:[\\/]*)
5445 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5446 ;;
5447 *)
5448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5449 for as_dir in $PATH
5450 do
5451 IFS=$as_save_IFS
5452 test -z "$as_dir" && as_dir=.
5453 for ac_exec_ext in '' $ac_executable_extensions; do
5454 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5455 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5456 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5457 break 2
5458 fi
5459 done
5460 done
5461 IFS=$as_save_IFS
5462
5463 ;;
5464 esac
5465 fi
5466 COMM=$ac_cv_path_COMM
5467 if test -n "$COMM"; then
5468 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5469 $as_echo "$COMM" >&6; }
5470 else
5471 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5472 $as_echo "no" >&6; }
5473 fi
5474
5475
5476 test -n "$COMM" && break
5477 done
5478
5479 else
5480 # If it succeeded, then it was overridden by the user. We will use it
5481 # for the tool.
5482
5483 # First remove it from the list of overridden variables, so we can test
5484 # for unknown variables in the end.
5485 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5486
5487 # Check if the provided tool contains a complete path.
5488 tool_specified="$COMM"
5489 tool_basename="${tool_specified##*/}"
5490 if test "x$tool_basename" = "x$tool_specified"; then
5491 # A command without a complete path is provided, search $PATH.
5492 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5493 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5494 # Extract the first word of "$tool_basename", so it can be a program name with args.
5495 set dummy $tool_basename; ac_word=$2
5496 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5497 $as_echo_n "checking for $ac_word... " >&6; }
5498 if ${ac_cv_path_COMM+:} false; then :
5499 $as_echo_n "(cached) " >&6
5500 else
5501 case $COMM in
5502 [\\/]* | ?:[\\/]*)
5503 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5504 ;;
5505 *)
5506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5507 for as_dir in $PATH
5508 do
5509 IFS=$as_save_IFS
5510 test -z "$as_dir" && as_dir=.
5511 for ac_exec_ext in '' $ac_executable_extensions; do
5512 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5513 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5514 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5515 break 2
5516 fi
5517 done
5518 done
5519 IFS=$as_save_IFS
5520
5521 ;;
5522 esac
5523 fi
5524 COMM=$ac_cv_path_COMM
5525 if test -n "$COMM"; then
5526 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5527 $as_echo "$COMM" >&6; }
5528 else
5529 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5530 $as_echo "no" >&6; }
5531 fi
5532
5533
5534 if test "x$COMM" = x; then
5535 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5536 fi
5537 else
5538 # Otherwise we believe it is a complete path. Use it as it is.
5539 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5540 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5542 $as_echo_n "checking for COMM... " >&6; }
5543 if test ! -x "$tool_specified"; then
5544 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5545 $as_echo "not found" >&6; }
5546 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5547 fi
5548 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5549 $as_echo "$tool_specified" >&6; }
5550 fi
5551 fi
5552 fi
5553
5554
5555
5556 if test "x$COMM" = x; then
5557 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5558 fi
5559
5560
5561
5562
5563
5564 # Publish this variable in the help.
5565
5566
5567 if test "x$CP" = x; then
5568 # The variable is not set by user, try to locate tool using the code snippet
5569 for ac_prog in cp
5570 do
5571 # Extract the first word of "$ac_prog", so it can be a program name with args.
5572 set dummy $ac_prog; ac_word=$2
5573 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5574 $as_echo_n "checking for $ac_word... " >&6; }
5575 if ${ac_cv_path_CP+:} false; then :
5576 $as_echo_n "(cached) " >&6
5577 else
5578 case $CP in
5579 [\\/]* | ?:[\\/]*)
5580 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5581 ;;
5582 *)
5583 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5584 for as_dir in $PATH
5585 do
5586 IFS=$as_save_IFS
5587 test -z "$as_dir" && as_dir=.
5588 for ac_exec_ext in '' $ac_executable_extensions; do
5589 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5590 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5591 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5592 break 2
5593 fi
5594 done
5595 done
5596 IFS=$as_save_IFS
5597
5598 ;;
5599 esac
5600 fi
5601 CP=$ac_cv_path_CP
5602 if test -n "$CP"; then
5603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5604 $as_echo "$CP" >&6; }
5605 else
5606 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5607 $as_echo "no" >&6; }
5608 fi
5609
5610
5611 test -n "$CP" && break
5612 done
5613
5614 else
5615 # The variable is set, but is it from the command line or the environment?
5616
5617 # Try to remove the string !CP! from our list.
5618 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5619 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5620 # If it failed, the variable was not from the command line. Ignore it,
5621 # but warn the user (except for BASH, which is always set by the calling BASH).
5622 if test "xCP" != xBASH; then
5623 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5624 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5625 fi
5626 # Try to locate tool using the code snippet
5627 for ac_prog in cp
5628 do
5629 # Extract the first word of "$ac_prog", so it can be a program name with args.
5630 set dummy $ac_prog; ac_word=$2
5631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5632 $as_echo_n "checking for $ac_word... " >&6; }
5633 if ${ac_cv_path_CP+:} false; then :
5634 $as_echo_n "(cached) " >&6
5635 else
5636 case $CP in
5637 [\\/]* | ?:[\\/]*)
5638 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5639 ;;
5640 *)
5641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5642 for as_dir in $PATH
5643 do
5644 IFS=$as_save_IFS
5645 test -z "$as_dir" && as_dir=.
5646 for ac_exec_ext in '' $ac_executable_extensions; do
5647 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5648 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5649 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5650 break 2
5651 fi
5652 done
5653 done
5654 IFS=$as_save_IFS
5655
5656 ;;
5657 esac
5658 fi
5659 CP=$ac_cv_path_CP
5660 if test -n "$CP"; then
5661 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5662 $as_echo "$CP" >&6; }
5663 else
5664 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5665 $as_echo "no" >&6; }
5666 fi
5667
5668
5669 test -n "$CP" && break
5670 done
5671
5672 else
5673 # If it succeeded, then it was overridden by the user. We will use it
5674 # for the tool.
5675
5676 # First remove it from the list of overridden variables, so we can test
5677 # for unknown variables in the end.
5678 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5679
5680 # Check if the provided tool contains a complete path.
5681 tool_specified="$CP"
5682 tool_basename="${tool_specified##*/}"
5683 if test "x$tool_basename" = "x$tool_specified"; then
5684 # A command without a complete path is provided, search $PATH.
5685 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5686 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5687 # Extract the first word of "$tool_basename", so it can be a program name with args.
5688 set dummy $tool_basename; ac_word=$2
5689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5690 $as_echo_n "checking for $ac_word... " >&6; }
5691 if ${ac_cv_path_CP+:} false; then :
5692 $as_echo_n "(cached) " >&6
5693 else
5694 case $CP in
5695 [\\/]* | ?:[\\/]*)
5696 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5697 ;;
5698 *)
5699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5700 for as_dir in $PATH
5701 do
5702 IFS=$as_save_IFS
5703 test -z "$as_dir" && as_dir=.
5704 for ac_exec_ext in '' $ac_executable_extensions; do
5705 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5706 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5707 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5708 break 2
5709 fi
5710 done
5711 done
5712 IFS=$as_save_IFS
5713
5714 ;;
5715 esac
5716 fi
5717 CP=$ac_cv_path_CP
5718 if test -n "$CP"; then
5719 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5720 $as_echo "$CP" >&6; }
5721 else
5722 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5723 $as_echo "no" >&6; }
5724 fi
5725
5726
5727 if test "x$CP" = x; then
5728 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5729 fi
5730 else
5731 # Otherwise we believe it is a complete path. Use it as it is.
5732 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5733 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5735 $as_echo_n "checking for CP... " >&6; }
5736 if test ! -x "$tool_specified"; then
5737 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5738 $as_echo "not found" >&6; }
5739 as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5740 fi
5741 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5742 $as_echo "$tool_specified" >&6; }
5743 fi
5744 fi
5745 fi
5746
5747
5748
5749 if test "x$CP" = x; then
5750 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5751 fi
5752
5753
5754
5755
5756
5757 # Publish this variable in the help.
5758
5759
5760 if test "x$CUT" = x; then
5761 # The variable is not set by user, try to locate tool using the code snippet
5762 for ac_prog in cut
5763 do
5764 # Extract the first word of "$ac_prog", so it can be a program name with args.
5765 set dummy $ac_prog; ac_word=$2
5766 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5767 $as_echo_n "checking for $ac_word... " >&6; }
5768 if ${ac_cv_path_CUT+:} false; then :
5769 $as_echo_n "(cached) " >&6
5770 else
5771 case $CUT in
5772 [\\/]* | ?:[\\/]*)
5773 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5774 ;;
5775 *)
5776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5777 for as_dir in $PATH
5778 do
5779 IFS=$as_save_IFS
5780 test -z "$as_dir" && as_dir=.
5781 for ac_exec_ext in '' $ac_executable_extensions; do
5782 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5783 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5784 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5785 break 2
5786 fi
5787 done
5788 done
5789 IFS=$as_save_IFS
5790
5791 ;;
5792 esac
5793 fi
5794 CUT=$ac_cv_path_CUT
5795 if test -n "$CUT"; then
5796 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5797 $as_echo "$CUT" >&6; }
5798 else
5799 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5800 $as_echo "no" >&6; }
5801 fi
5802
5803
5804 test -n "$CUT" && break
5805 done
5806
5807 else
5808 # The variable is set, but is it from the command line or the environment?
5809
5810 # Try to remove the string !CUT! from our list.
5811 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5812 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5813 # If it failed, the variable was not from the command line. Ignore it,
5814 # but warn the user (except for BASH, which is always set by the calling BASH).
5815 if test "xCUT" != xBASH; then
5816 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5817 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5818 fi
5819 # Try to locate tool using the code snippet
5820 for ac_prog in cut
5821 do
5822 # Extract the first word of "$ac_prog", so it can be a program name with args.
5823 set dummy $ac_prog; ac_word=$2
5824 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5825 $as_echo_n "checking for $ac_word... " >&6; }
5826 if ${ac_cv_path_CUT+:} false; then :
5827 $as_echo_n "(cached) " >&6
5828 else
5829 case $CUT in
5830 [\\/]* | ?:[\\/]*)
5831 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5832 ;;
5833 *)
5834 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5835 for as_dir in $PATH
5836 do
5837 IFS=$as_save_IFS
5838 test -z "$as_dir" && as_dir=.
5839 for ac_exec_ext in '' $ac_executable_extensions; do
5840 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5841 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5842 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5843 break 2
5844 fi
5845 done
5846 done
5847 IFS=$as_save_IFS
5848
5849 ;;
5850 esac
5851 fi
5852 CUT=$ac_cv_path_CUT
5853 if test -n "$CUT"; then
5854 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5855 $as_echo "$CUT" >&6; }
5856 else
5857 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5858 $as_echo "no" >&6; }
5859 fi
5860
5861
5862 test -n "$CUT" && break
5863 done
5864
5865 else
5866 # If it succeeded, then it was overridden by the user. We will use it
5867 # for the tool.
5868
5869 # First remove it from the list of overridden variables, so we can test
5870 # for unknown variables in the end.
5871 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5872
5873 # Check if the provided tool contains a complete path.
5874 tool_specified="$CUT"
5875 tool_basename="${tool_specified##*/}"
5876 if test "x$tool_basename" = "x$tool_specified"; then
5877 # A command without a complete path is provided, search $PATH.
5878 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5879 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5880 # Extract the first word of "$tool_basename", so it can be a program name with args.
5881 set dummy $tool_basename; ac_word=$2
5882 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5883 $as_echo_n "checking for $ac_word... " >&6; }
5884 if ${ac_cv_path_CUT+:} false; then :
5885 $as_echo_n "(cached) " >&6
5886 else
5887 case $CUT in
5888 [\\/]* | ?:[\\/]*)
5889 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5890 ;;
5891 *)
5892 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5893 for as_dir in $PATH
5894 do
5895 IFS=$as_save_IFS
5896 test -z "$as_dir" && as_dir=.
5897 for ac_exec_ext in '' $ac_executable_extensions; do
5898 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5899 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5900 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5901 break 2
5902 fi
5903 done
5904 done
5905 IFS=$as_save_IFS
5906
5907 ;;
5908 esac
5909 fi
5910 CUT=$ac_cv_path_CUT
5911 if test -n "$CUT"; then
5912 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5913 $as_echo "$CUT" >&6; }
5914 else
5915 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5916 $as_echo "no" >&6; }
5917 fi
5918
5919
5920 if test "x$CUT" = x; then
5921 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5922 fi
5923 else
5924 # Otherwise we believe it is a complete path. Use it as it is.
5925 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5926 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5927 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5928 $as_echo_n "checking for CUT... " >&6; }
5929 if test ! -x "$tool_specified"; then
5930 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5931 $as_echo "not found" >&6; }
5932 as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5933 fi
5934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5935 $as_echo "$tool_specified" >&6; }
5936 fi
5937 fi
5938 fi
5939
5940
5941
5942 if test "x$CUT" = x; then
5943 as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5944 fi
5945
5946
5947
5948
5949
5950 # Publish this variable in the help.
5951
5952
5953 if test "x$DATE" = x; then
5954 # The variable is not set by user, try to locate tool using the code snippet
5955 for ac_prog in date
5956 do
5957 # Extract the first word of "$ac_prog", so it can be a program name with args.
5958 set dummy $ac_prog; ac_word=$2
5959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5960 $as_echo_n "checking for $ac_word... " >&6; }
5961 if ${ac_cv_path_DATE+:} false; then :
5962 $as_echo_n "(cached) " >&6
5963 else
5964 case $DATE in
5965 [\\/]* | ?:[\\/]*)
5966 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5967 ;;
5968 *)
5969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5970 for as_dir in $PATH
5971 do
5972 IFS=$as_save_IFS
5973 test -z "$as_dir" && as_dir=.
5974 for ac_exec_ext in '' $ac_executable_extensions; do
5975 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5976 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5977 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5978 break 2
5979 fi
5980 done
5981 done
5982 IFS=$as_save_IFS
5983
5984 ;;
5985 esac
5986 fi
5987 DATE=$ac_cv_path_DATE
5988 if test -n "$DATE"; then
5989 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5990 $as_echo "$DATE" >&6; }
5991 else
5992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5993 $as_echo "no" >&6; }
5994 fi
5995
5996
5997 test -n "$DATE" && break
5998 done
5999
6000 else
6001 # The variable is set, but is it from the command line or the environment?
6002
6003 # Try to remove the string !DATE! from our list.
6004 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6005 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6006 # If it failed, the variable was not from the command line. Ignore it,
6007 # but warn the user (except for BASH, which is always set by the calling BASH).
6008 if test "xDATE" != xBASH; then
6009 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6010 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6011 fi
6012 # Try to locate tool using the code snippet
6013 for ac_prog in date
6014 do
6015 # Extract the first word of "$ac_prog", so it can be a program name with args.
6016 set dummy $ac_prog; ac_word=$2
6017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6018 $as_echo_n "checking for $ac_word... " >&6; }
6019 if ${ac_cv_path_DATE+:} false; then :
6020 $as_echo_n "(cached) " >&6
6021 else
6022 case $DATE in
6023 [\\/]* | ?:[\\/]*)
6024 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6025 ;;
6026 *)
6027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6028 for as_dir in $PATH
6029 do
6030 IFS=$as_save_IFS
6031 test -z "$as_dir" && as_dir=.
6032 for ac_exec_ext in '' $ac_executable_extensions; do
6033 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6034 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6035 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6036 break 2
6037 fi
6038 done
6039 done
6040 IFS=$as_save_IFS
6041
6042 ;;
6043 esac
6044 fi
6045 DATE=$ac_cv_path_DATE
6046 if test -n "$DATE"; then
6047 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6048 $as_echo "$DATE" >&6; }
6049 else
6050 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6051 $as_echo "no" >&6; }
6052 fi
6053
6054
6055 test -n "$DATE" && break
6056 done
6057
6058 else
6059 # If it succeeded, then it was overridden by the user. We will use it
6060 # for the tool.
6061
6062 # First remove it from the list of overridden variables, so we can test
6063 # for unknown variables in the end.
6064 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6065
6066 # Check if the provided tool contains a complete path.
6067 tool_specified="$DATE"
6068 tool_basename="${tool_specified##*/}"
6069 if test "x$tool_basename" = "x$tool_specified"; then
6070 # A command without a complete path is provided, search $PATH.
6071 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6072 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6073 # Extract the first word of "$tool_basename", so it can be a program name with args.
6074 set dummy $tool_basename; ac_word=$2
6075 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6076 $as_echo_n "checking for $ac_word... " >&6; }
6077 if ${ac_cv_path_DATE+:} false; then :
6078 $as_echo_n "(cached) " >&6
6079 else
6080 case $DATE in
6081 [\\/]* | ?:[\\/]*)
6082 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6083 ;;
6084 *)
6085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6086 for as_dir in $PATH
6087 do
6088 IFS=$as_save_IFS
6089 test -z "$as_dir" && as_dir=.
6090 for ac_exec_ext in '' $ac_executable_extensions; do
6091 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6092 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6093 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6094 break 2
6095 fi
6096 done
6097 done
6098 IFS=$as_save_IFS
6099
6100 ;;
6101 esac
6102 fi
6103 DATE=$ac_cv_path_DATE
6104 if test -n "$DATE"; then
6105 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6106 $as_echo "$DATE" >&6; }
6107 else
6108 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6109 $as_echo "no" >&6; }
6110 fi
6111
6112
6113 if test "x$DATE" = x; then
6114 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6115 fi
6116 else
6117 # Otherwise we believe it is a complete path. Use it as it is.
6118 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6119 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6120 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6121 $as_echo_n "checking for DATE... " >&6; }
6122 if test ! -x "$tool_specified"; then
6123 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6124 $as_echo "not found" >&6; }
6125 as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6126 fi
6127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6128 $as_echo "$tool_specified" >&6; }
6129 fi
6130 fi
6131 fi
6132
6133
6134
6135 if test "x$DATE" = x; then
6136 as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6137 fi
6138
6139
6140
6141
6142
6143 # Publish this variable in the help.
6144
6145
6146 if test "x$DIFF" = x; then
6147 # The variable is not set by user, try to locate tool using the code snippet
6148 for ac_prog in gdiff diff
6149 do
6150 # Extract the first word of "$ac_prog", so it can be a program name with args.
6151 set dummy $ac_prog; ac_word=$2
6152 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6153 $as_echo_n "checking for $ac_word... " >&6; }
6154 if ${ac_cv_path_DIFF+:} false; then :
6155 $as_echo_n "(cached) " >&6
6156 else
6157 case $DIFF in
6158 [\\/]* | ?:[\\/]*)
6159 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6160 ;;
6161 *)
6162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6163 for as_dir in $PATH
6164 do
6165 IFS=$as_save_IFS
6166 test -z "$as_dir" && as_dir=.
6167 for ac_exec_ext in '' $ac_executable_extensions; do
6168 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6169 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6170 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6171 break 2
6172 fi
6173 done
6174 done
6175 IFS=$as_save_IFS
6176
6177 ;;
6178 esac
6179 fi
6180 DIFF=$ac_cv_path_DIFF
6181 if test -n "$DIFF"; then
6182 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6183 $as_echo "$DIFF" >&6; }
6184 else
6185 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6186 $as_echo "no" >&6; }
6187 fi
6188
6189
6190 test -n "$DIFF" && break
6191 done
6192
6193 else
6194 # The variable is set, but is it from the command line or the environment?
6195
6196 # Try to remove the string !DIFF! from our list.
6197 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6198 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6199 # If it failed, the variable was not from the command line. Ignore it,
6200 # but warn the user (except for BASH, which is always set by the calling BASH).
6201 if test "xDIFF" != xBASH; then
6202 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6203 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6204 fi
6205 # Try to locate tool using the code snippet
6206 for ac_prog in gdiff diff
6207 do
6208 # Extract the first word of "$ac_prog", so it can be a program name with args.
6209 set dummy $ac_prog; ac_word=$2
6210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6211 $as_echo_n "checking for $ac_word... " >&6; }
6212 if ${ac_cv_path_DIFF+:} false; then :
6213 $as_echo_n "(cached) " >&6
6214 else
6215 case $DIFF in
6216 [\\/]* | ?:[\\/]*)
6217 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6218 ;;
6219 *)
6220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6221 for as_dir in $PATH
6222 do
6223 IFS=$as_save_IFS
6224 test -z "$as_dir" && as_dir=.
6225 for ac_exec_ext in '' $ac_executable_extensions; do
6226 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6227 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6228 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6229 break 2
6230 fi
6231 done
6232 done
6233 IFS=$as_save_IFS
6234
6235 ;;
6236 esac
6237 fi
6238 DIFF=$ac_cv_path_DIFF
6239 if test -n "$DIFF"; then
6240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6241 $as_echo "$DIFF" >&6; }
6242 else
6243 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6244 $as_echo "no" >&6; }
6245 fi
6246
6247
6248 test -n "$DIFF" && break
6249 done
6250
6251 else
6252 # If it succeeded, then it was overridden by the user. We will use it
6253 # for the tool.
6254
6255 # First remove it from the list of overridden variables, so we can test
6256 # for unknown variables in the end.
6257 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6258
6259 # Check if the provided tool contains a complete path.
6260 tool_specified="$DIFF"
6261 tool_basename="${tool_specified##*/}"
6262 if test "x$tool_basename" = "x$tool_specified"; then
6263 # A command without a complete path is provided, search $PATH.
6264 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6265 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6266 # Extract the first word of "$tool_basename", so it can be a program name with args.
6267 set dummy $tool_basename; ac_word=$2
6268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6269 $as_echo_n "checking for $ac_word... " >&6; }
6270 if ${ac_cv_path_DIFF+:} false; then :
6271 $as_echo_n "(cached) " >&6
6272 else
6273 case $DIFF in
6274 [\\/]* | ?:[\\/]*)
6275 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6276 ;;
6277 *)
6278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6279 for as_dir in $PATH
6280 do
6281 IFS=$as_save_IFS
6282 test -z "$as_dir" && as_dir=.
6283 for ac_exec_ext in '' $ac_executable_extensions; do
6284 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6285 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6286 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6287 break 2
6288 fi
6289 done
6290 done
6291 IFS=$as_save_IFS
6292
6293 ;;
6294 esac
6295 fi
6296 DIFF=$ac_cv_path_DIFF
6297 if test -n "$DIFF"; then
6298 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6299 $as_echo "$DIFF" >&6; }
6300 else
6301 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6302 $as_echo "no" >&6; }
6303 fi
6304
6305
6306 if test "x$DIFF" = x; then
6307 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6308 fi
6309 else
6310 # Otherwise we believe it is a complete path. Use it as it is.
6311 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6312 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6314 $as_echo_n "checking for DIFF... " >&6; }
6315 if test ! -x "$tool_specified"; then
6316 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6317 $as_echo "not found" >&6; }
6318 as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6319 fi
6320 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6321 $as_echo "$tool_specified" >&6; }
6322 fi
6323 fi
6324 fi
6325
6326
6327
6328 if test "x$DIFF" = x; then
6329 as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6330 fi
6331
6332
6333
6334
6335
6336 # Publish this variable in the help.
6337
6338
6339 if test "x$DIRNAME" = x; then
6340 # The variable is not set by user, try to locate tool using the code snippet
6341 for ac_prog in dirname
6342 do
6343 # Extract the first word of "$ac_prog", so it can be a program name with args.
6344 set dummy $ac_prog; ac_word=$2
6345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6346 $as_echo_n "checking for $ac_word... " >&6; }
6347 if ${ac_cv_path_DIRNAME+:} false; then :
6348 $as_echo_n "(cached) " >&6
6349 else
6350 case $DIRNAME in
6351 [\\/]* | ?:[\\/]*)
6352 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6353 ;;
6354 *)
6355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6356 for as_dir in $PATH
6357 do
6358 IFS=$as_save_IFS
6359 test -z "$as_dir" && as_dir=.
6360 for ac_exec_ext in '' $ac_executable_extensions; do
6361 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6362 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6363 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6364 break 2
6365 fi
6366 done
6367 done
6368 IFS=$as_save_IFS
6369
6370 ;;
6371 esac
6372 fi
6373 DIRNAME=$ac_cv_path_DIRNAME
6374 if test -n "$DIRNAME"; then
6375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6376 $as_echo "$DIRNAME" >&6; }
6377 else
6378 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6379 $as_echo "no" >&6; }
6380 fi
6381
6382
6383 test -n "$DIRNAME" && break
6384 done
6385
6386 else
6387 # The variable is set, but is it from the command line or the environment?
6388
6389 # Try to remove the string !DIRNAME! from our list.
6390 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6391 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6392 # If it failed, the variable was not from the command line. Ignore it,
6393 # but warn the user (except for BASH, which is always set by the calling BASH).
6394 if test "xDIRNAME" != xBASH; then
6395 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6396 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6397 fi
6398 # Try to locate tool using the code snippet
6399 for ac_prog in dirname
6400 do
6401 # Extract the first word of "$ac_prog", so it can be a program name with args.
6402 set dummy $ac_prog; ac_word=$2
6403 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6404 $as_echo_n "checking for $ac_word... " >&6; }
6405 if ${ac_cv_path_DIRNAME+:} false; then :
6406 $as_echo_n "(cached) " >&6
6407 else
6408 case $DIRNAME in
6409 [\\/]* | ?:[\\/]*)
6410 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6411 ;;
6412 *)
6413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6414 for as_dir in $PATH
6415 do
6416 IFS=$as_save_IFS
6417 test -z "$as_dir" && as_dir=.
6418 for ac_exec_ext in '' $ac_executable_extensions; do
6419 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6420 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6421 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6422 break 2
6423 fi
6424 done
6425 done
6426 IFS=$as_save_IFS
6427
6428 ;;
6429 esac
6430 fi
6431 DIRNAME=$ac_cv_path_DIRNAME
6432 if test -n "$DIRNAME"; then
6433 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6434 $as_echo "$DIRNAME" >&6; }
6435 else
6436 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6437 $as_echo "no" >&6; }
6438 fi
6439
6440
6441 test -n "$DIRNAME" && break
6442 done
6443
6444 else
6445 # If it succeeded, then it was overridden by the user. We will use it
6446 # for the tool.
6447
6448 # First remove it from the list of overridden variables, so we can test
6449 # for unknown variables in the end.
6450 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6451
6452 # Check if the provided tool contains a complete path.
6453 tool_specified="$DIRNAME"
6454 tool_basename="${tool_specified##*/}"
6455 if test "x$tool_basename" = "x$tool_specified"; then
6456 # A command without a complete path is provided, search $PATH.
6457 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6458 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6459 # Extract the first word of "$tool_basename", so it can be a program name with args.
6460 set dummy $tool_basename; ac_word=$2
6461 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6462 $as_echo_n "checking for $ac_word... " >&6; }
6463 if ${ac_cv_path_DIRNAME+:} false; then :
6464 $as_echo_n "(cached) " >&6
6465 else
6466 case $DIRNAME in
6467 [\\/]* | ?:[\\/]*)
6468 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6469 ;;
6470 *)
6471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6472 for as_dir in $PATH
6473 do
6474 IFS=$as_save_IFS
6475 test -z "$as_dir" && as_dir=.
6476 for ac_exec_ext in '' $ac_executable_extensions; do
6477 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6478 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6479 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6480 break 2
6481 fi
6482 done
6483 done
6484 IFS=$as_save_IFS
6485
6486 ;;
6487 esac
6488 fi
6489 DIRNAME=$ac_cv_path_DIRNAME
6490 if test -n "$DIRNAME"; then
6491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6492 $as_echo "$DIRNAME" >&6; }
6493 else
6494 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6495 $as_echo "no" >&6; }
6496 fi
6497
6498
6499 if test "x$DIRNAME" = x; then
6500 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6501 fi
6502 else
6503 # Otherwise we believe it is a complete path. Use it as it is.
6504 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6505 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6506 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6507 $as_echo_n "checking for DIRNAME... " >&6; }
6508 if test ! -x "$tool_specified"; then
6509 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6510 $as_echo "not found" >&6; }
6511 as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6512 fi
6513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6514 $as_echo "$tool_specified" >&6; }
6515 fi
6516 fi
6517 fi
6518
6519
6520
6521 if test "x$DIRNAME" = x; then
6522 as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6523 fi
6524
6525
6526
6527
6528
6529 # Publish this variable in the help.
6530
6531
6532 if test "x$ECHO" = x; then
6533 # The variable is not set by user, try to locate tool using the code snippet
6534 for ac_prog in echo
6535 do
6536 # Extract the first word of "$ac_prog", so it can be a program name with args.
6537 set dummy $ac_prog; ac_word=$2
6538 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6539 $as_echo_n "checking for $ac_word... " >&6; }
6540 if ${ac_cv_path_ECHO+:} false; then :
6541 $as_echo_n "(cached) " >&6
6542 else
6543 case $ECHO in
6544 [\\/]* | ?:[\\/]*)
6545 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6546 ;;
6547 *)
6548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6549 for as_dir in $PATH
6550 do
6551 IFS=$as_save_IFS
6552 test -z "$as_dir" && as_dir=.
6553 for ac_exec_ext in '' $ac_executable_extensions; do
6554 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6555 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6556 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6557 break 2
6558 fi
6559 done
6560 done
6561 IFS=$as_save_IFS
6562
6563 ;;
6564 esac
6565 fi
6566 ECHO=$ac_cv_path_ECHO
6567 if test -n "$ECHO"; then
6568 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6569 $as_echo "$ECHO" >&6; }
6570 else
6571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6572 $as_echo "no" >&6; }
6573 fi
6574
6575
6576 test -n "$ECHO" && break
6577 done
6578
6579 else
6580 # The variable is set, but is it from the command line or the environment?
6581
6582 # Try to remove the string !ECHO! from our list.
6583 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6584 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6585 # If it failed, the variable was not from the command line. Ignore it,
6586 # but warn the user (except for BASH, which is always set by the calling BASH).
6587 if test "xECHO" != xBASH; then
6588 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6589 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6590 fi
6591 # Try to locate tool using the code snippet
6592 for ac_prog in echo
6593 do
6594 # Extract the first word of "$ac_prog", so it can be a program name with args.
6595 set dummy $ac_prog; ac_word=$2
6596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6597 $as_echo_n "checking for $ac_word... " >&6; }
6598 if ${ac_cv_path_ECHO+:} false; then :
6599 $as_echo_n "(cached) " >&6
6600 else
6601 case $ECHO in
6602 [\\/]* | ?:[\\/]*)
6603 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6604 ;;
6605 *)
6606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 for as_dir in $PATH
6608 do
6609 IFS=$as_save_IFS
6610 test -z "$as_dir" && as_dir=.
6611 for ac_exec_ext in '' $ac_executable_extensions; do
6612 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6614 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6615 break 2
6616 fi
6617 done
6618 done
6619 IFS=$as_save_IFS
6620
6621 ;;
6622 esac
6623 fi
6624 ECHO=$ac_cv_path_ECHO
6625 if test -n "$ECHO"; then
6626 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6627 $as_echo "$ECHO" >&6; }
6628 else
6629 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6630 $as_echo "no" >&6; }
6631 fi
6632
6633
6634 test -n "$ECHO" && break
6635 done
6636
6637 else
6638 # If it succeeded, then it was overridden by the user. We will use it
6639 # for the tool.
6640
6641 # First remove it from the list of overridden variables, so we can test
6642 # for unknown variables in the end.
6643 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6644
6645 # Check if the provided tool contains a complete path.
6646 tool_specified="$ECHO"
6647 tool_basename="${tool_specified##*/}"
6648 if test "x$tool_basename" = "x$tool_specified"; then
6649 # A command without a complete path is provided, search $PATH.
6650 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6651 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6652 # Extract the first word of "$tool_basename", so it can be a program name with args.
6653 set dummy $tool_basename; ac_word=$2
6654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6655 $as_echo_n "checking for $ac_word... " >&6; }
6656 if ${ac_cv_path_ECHO+:} false; then :
6657 $as_echo_n "(cached) " >&6
6658 else
6659 case $ECHO in
6660 [\\/]* | ?:[\\/]*)
6661 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6662 ;;
6663 *)
6664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 for as_dir in $PATH
6666 do
6667 IFS=$as_save_IFS
6668 test -z "$as_dir" && as_dir=.
6669 for ac_exec_ext in '' $ac_executable_extensions; do
6670 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6672 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6673 break 2
6674 fi
6675 done
6676 done
6677 IFS=$as_save_IFS
6678
6679 ;;
6680 esac
6681 fi
6682 ECHO=$ac_cv_path_ECHO
6683 if test -n "$ECHO"; then
6684 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6685 $as_echo "$ECHO" >&6; }
6686 else
6687 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6688 $as_echo "no" >&6; }
6689 fi
6690
6691
6692 if test "x$ECHO" = x; then
6693 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6694 fi
6695 else
6696 # Otherwise we believe it is a complete path. Use it as it is.
6697 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6698 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6700 $as_echo_n "checking for ECHO... " >&6; }
6701 if test ! -x "$tool_specified"; then
6702 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6703 $as_echo "not found" >&6; }
6704 as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6705 fi
6706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6707 $as_echo "$tool_specified" >&6; }
6708 fi
6709 fi
6710 fi
6711
6712
6713
6714 if test "x$ECHO" = x; then
6715 as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6716 fi
6717
6718
6719
6720
6721
6722 # Publish this variable in the help.
6723
6724
6725 if test "x$EXPR" = x; then
6726 # The variable is not set by user, try to locate tool using the code snippet
6727 for ac_prog in expr
6728 do
6729 # Extract the first word of "$ac_prog", so it can be a program name with args.
6730 set dummy $ac_prog; ac_word=$2
6731 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6732 $as_echo_n "checking for $ac_word... " >&6; }
6733 if ${ac_cv_path_EXPR+:} false; then :
6734 $as_echo_n "(cached) " >&6
6735 else
6736 case $EXPR in
6737 [\\/]* | ?:[\\/]*)
6738 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6739 ;;
6740 *)
6741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6742 for as_dir in $PATH
6743 do
6744 IFS=$as_save_IFS
6745 test -z "$as_dir" && as_dir=.
6746 for ac_exec_ext in '' $ac_executable_extensions; do
6747 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6748 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6749 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6750 break 2
6751 fi
6752 done
6753 done
6754 IFS=$as_save_IFS
6755
6756 ;;
6757 esac
6758 fi
6759 EXPR=$ac_cv_path_EXPR
6760 if test -n "$EXPR"; then
6761 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6762 $as_echo "$EXPR" >&6; }
6763 else
6764 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6765 $as_echo "no" >&6; }
6766 fi
6767
6768
6769 test -n "$EXPR" && break
6770 done
6771
6772 else
6773 # The variable is set, but is it from the command line or the environment?
6774
6775 # Try to remove the string !EXPR! from our list.
6776 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6777 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6778 # If it failed, the variable was not from the command line. Ignore it,
6779 # but warn the user (except for BASH, which is always set by the calling BASH).
6780 if test "xEXPR" != xBASH; then
6781 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6782 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6783 fi
6784 # Try to locate tool using the code snippet
6785 for ac_prog in expr
6786 do
6787 # Extract the first word of "$ac_prog", so it can be a program name with args.
6788 set dummy $ac_prog; ac_word=$2
6789 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6790 $as_echo_n "checking for $ac_word... " >&6; }
6791 if ${ac_cv_path_EXPR+:} false; then :
6792 $as_echo_n "(cached) " >&6
6793 else
6794 case $EXPR in
6795 [\\/]* | ?:[\\/]*)
6796 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6797 ;;
6798 *)
6799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6800 for as_dir in $PATH
6801 do
6802 IFS=$as_save_IFS
6803 test -z "$as_dir" && as_dir=.
6804 for ac_exec_ext in '' $ac_executable_extensions; do
6805 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6806 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6807 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6808 break 2
6809 fi
6810 done
6811 done
6812 IFS=$as_save_IFS
6813
6814 ;;
6815 esac
6816 fi
6817 EXPR=$ac_cv_path_EXPR
6818 if test -n "$EXPR"; then
6819 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6820 $as_echo "$EXPR" >&6; }
6821 else
6822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6823 $as_echo "no" >&6; }
6824 fi
6825
6826
6827 test -n "$EXPR" && break
6828 done
6829
6830 else
6831 # If it succeeded, then it was overridden by the user. We will use it
6832 # for the tool.
6833
6834 # First remove it from the list of overridden variables, so we can test
6835 # for unknown variables in the end.
6836 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6837
6838 # Check if the provided tool contains a complete path.
6839 tool_specified="$EXPR"
6840 tool_basename="${tool_specified##*/}"
6841 if test "x$tool_basename" = "x$tool_specified"; then
6842 # A command without a complete path is provided, search $PATH.
6843 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6844 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6845 # Extract the first word of "$tool_basename", so it can be a program name with args.
6846 set dummy $tool_basename; ac_word=$2
6847 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6848 $as_echo_n "checking for $ac_word... " >&6; }
6849 if ${ac_cv_path_EXPR+:} false; then :
6850 $as_echo_n "(cached) " >&6
6851 else
6852 case $EXPR in
6853 [\\/]* | ?:[\\/]*)
6854 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6855 ;;
6856 *)
6857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6858 for as_dir in $PATH
6859 do
6860 IFS=$as_save_IFS
6861 test -z "$as_dir" && as_dir=.
6862 for ac_exec_ext in '' $ac_executable_extensions; do
6863 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6864 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6865 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6866 break 2
6867 fi
6868 done
6869 done
6870 IFS=$as_save_IFS
6871
6872 ;;
6873 esac
6874 fi
6875 EXPR=$ac_cv_path_EXPR
6876 if test -n "$EXPR"; then
6877 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6878 $as_echo "$EXPR" >&6; }
6879 else
6880 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6881 $as_echo "no" >&6; }
6882 fi
6883
6884
6885 if test "x$EXPR" = x; then
6886 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6887 fi
6888 else
6889 # Otherwise we believe it is a complete path. Use it as it is.
6890 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6891 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6892 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6893 $as_echo_n "checking for EXPR... " >&6; }
6894 if test ! -x "$tool_specified"; then
6895 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6896 $as_echo "not found" >&6; }
6897 as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6898 fi
6899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6900 $as_echo "$tool_specified" >&6; }
6901 fi
6902 fi
6903 fi
6904
6905
6906
6907 if test "x$EXPR" = x; then
6908 as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6909 fi
6910
6911
6912
6913
6914
6915 # Publish this variable in the help.
6916
6917
6918 if test "x$FILE" = x; then
6919 # The variable is not set by user, try to locate tool using the code snippet
6920 for ac_prog in file
6921 do
6922 # Extract the first word of "$ac_prog", so it can be a program name with args.
6923 set dummy $ac_prog; ac_word=$2
6924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6925 $as_echo_n "checking for $ac_word... " >&6; }
6926 if ${ac_cv_path_FILE+:} false; then :
6927 $as_echo_n "(cached) " >&6
6928 else
6929 case $FILE in
6930 [\\/]* | ?:[\\/]*)
6931 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6932 ;;
6933 *)
6934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6935 for as_dir in $PATH
6936 do
6937 IFS=$as_save_IFS
6938 test -z "$as_dir" && as_dir=.
6939 for ac_exec_ext in '' $ac_executable_extensions; do
6940 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6941 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6942 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6943 break 2
6944 fi
6945 done
6946 done
6947 IFS=$as_save_IFS
6948
6949 ;;
6950 esac
6951 fi
6952 FILE=$ac_cv_path_FILE
6953 if test -n "$FILE"; then
6954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6955 $as_echo "$FILE" >&6; }
6956 else
6957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6958 $as_echo "no" >&6; }
6959 fi
6960
6961
6962 test -n "$FILE" && break
6963 done
6964
6965 else
6966 # The variable is set, but is it from the command line or the environment?
6967
6968 # Try to remove the string !FILE! from our list.
6969 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6970 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6971 # If it failed, the variable was not from the command line. Ignore it,
6972 # but warn the user (except for BASH, which is always set by the calling BASH).
6973 if test "xFILE" != xBASH; then
6974 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6975 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6976 fi
6977 # Try to locate tool using the code snippet
6978 for ac_prog in file
6979 do
6980 # Extract the first word of "$ac_prog", so it can be a program name with args.
6981 set dummy $ac_prog; ac_word=$2
6982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6983 $as_echo_n "checking for $ac_word... " >&6; }
6984 if ${ac_cv_path_FILE+:} false; then :
6985 $as_echo_n "(cached) " >&6
6986 else
6987 case $FILE in
6988 [\\/]* | ?:[\\/]*)
6989 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6990 ;;
6991 *)
6992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6993 for as_dir in $PATH
6994 do
6995 IFS=$as_save_IFS
6996 test -z "$as_dir" && as_dir=.
6997 for ac_exec_ext in '' $ac_executable_extensions; do
6998 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6999 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7000 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7001 break 2
7002 fi
7003 done
7004 done
7005 IFS=$as_save_IFS
7006
7007 ;;
7008 esac
7009 fi
7010 FILE=$ac_cv_path_FILE
7011 if test -n "$FILE"; then
7012 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7013 $as_echo "$FILE" >&6; }
7014 else
7015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7016 $as_echo "no" >&6; }
7017 fi
7018
7019
7020 test -n "$FILE" && break
7021 done
7022
7023 else
7024 # If it succeeded, then it was overridden by the user. We will use it
7025 # for the tool.
7026
7027 # First remove it from the list of overridden variables, so we can test
7028 # for unknown variables in the end.
7029 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7030
7031 # Check if the provided tool contains a complete path.
7032 tool_specified="$FILE"
7033 tool_basename="${tool_specified##*/}"
7034 if test "x$tool_basename" = "x$tool_specified"; then
7035 # A command without a complete path is provided, search $PATH.
7036 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7037 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7038 # Extract the first word of "$tool_basename", so it can be a program name with args.
7039 set dummy $tool_basename; ac_word=$2
7040 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7041 $as_echo_n "checking for $ac_word... " >&6; }
7042 if ${ac_cv_path_FILE+:} false; then :
7043 $as_echo_n "(cached) " >&6
7044 else
7045 case $FILE in
7046 [\\/]* | ?:[\\/]*)
7047 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7048 ;;
7049 *)
7050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7051 for as_dir in $PATH
7052 do
7053 IFS=$as_save_IFS
7054 test -z "$as_dir" && as_dir=.
7055 for ac_exec_ext in '' $ac_executable_extensions; do
7056 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7057 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7058 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7059 break 2
7060 fi
7061 done
7062 done
7063 IFS=$as_save_IFS
7064
7065 ;;
7066 esac
7067 fi
7068 FILE=$ac_cv_path_FILE
7069 if test -n "$FILE"; then
7070 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7071 $as_echo "$FILE" >&6; }
7072 else
7073 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7074 $as_echo "no" >&6; }
7075 fi
7076
7077
7078 if test "x$FILE" = x; then
7079 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7080 fi
7081 else
7082 # Otherwise we believe it is a complete path. Use it as it is.
7083 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7084 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7086 $as_echo_n "checking for FILE... " >&6; }
7087 if test ! -x "$tool_specified"; then
7088 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7089 $as_echo "not found" >&6; }
7090 as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7091 fi
7092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7093 $as_echo "$tool_specified" >&6; }
7094 fi
7095 fi
7096 fi
7097
7098
7099
7100 if test "x$FILE" = x; then
7101 as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7102 fi
7103
7104
7105
7106
7107
7108 # Publish this variable in the help.
7109
7110
7111 if test "x$FIND" = x; then
7112 # The variable is not set by user, try to locate tool using the code snippet
7113 for ac_prog in find
7114 do
7115 # Extract the first word of "$ac_prog", so it can be a program name with args.
7116 set dummy $ac_prog; ac_word=$2
7117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7118 $as_echo_n "checking for $ac_word... " >&6; }
7119 if ${ac_cv_path_FIND+:} false; then :
7120 $as_echo_n "(cached) " >&6
7121 else
7122 case $FIND in
7123 [\\/]* | ?:[\\/]*)
7124 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7125 ;;
7126 *)
7127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7128 for as_dir in $PATH
7129 do
7130 IFS=$as_save_IFS
7131 test -z "$as_dir" && as_dir=.
7132 for ac_exec_ext in '' $ac_executable_extensions; do
7133 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7134 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7135 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7136 break 2
7137 fi
7138 done
7139 done
7140 IFS=$as_save_IFS
7141
7142 ;;
7143 esac
7144 fi
7145 FIND=$ac_cv_path_FIND
7146 if test -n "$FIND"; then
7147 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7148 $as_echo "$FIND" >&6; }
7149 else
7150 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7151 $as_echo "no" >&6; }
7152 fi
7153
7154
7155 test -n "$FIND" && break
7156 done
7157
7158 else
7159 # The variable is set, but is it from the command line or the environment?
7160
7161 # Try to remove the string !FIND! from our list.
7162 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7163 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7164 # If it failed, the variable was not from the command line. Ignore it,
7165 # but warn the user (except for BASH, which is always set by the calling BASH).
7166 if test "xFIND" != xBASH; then
7167 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7168 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7169 fi
7170 # Try to locate tool using the code snippet
7171 for ac_prog in find
7172 do
7173 # Extract the first word of "$ac_prog", so it can be a program name with args.
7174 set dummy $ac_prog; ac_word=$2
7175 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7176 $as_echo_n "checking for $ac_word... " >&6; }
7177 if ${ac_cv_path_FIND+:} false; then :
7178 $as_echo_n "(cached) " >&6
7179 else
7180 case $FIND in
7181 [\\/]* | ?:[\\/]*)
7182 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7183 ;;
7184 *)
7185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7186 for as_dir in $PATH
7187 do
7188 IFS=$as_save_IFS
7189 test -z "$as_dir" && as_dir=.
7190 for ac_exec_ext in '' $ac_executable_extensions; do
7191 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7192 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7193 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7194 break 2
7195 fi
7196 done
7197 done
7198 IFS=$as_save_IFS
7199
7200 ;;
7201 esac
7202 fi
7203 FIND=$ac_cv_path_FIND
7204 if test -n "$FIND"; then
7205 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7206 $as_echo "$FIND" >&6; }
7207 else
7208 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7209 $as_echo "no" >&6; }
7210 fi
7211
7212
7213 test -n "$FIND" && break
7214 done
7215
7216 else
7217 # If it succeeded, then it was overridden by the user. We will use it
7218 # for the tool.
7219
7220 # First remove it from the list of overridden variables, so we can test
7221 # for unknown variables in the end.
7222 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7223
7224 # Check if the provided tool contains a complete path.
7225 tool_specified="$FIND"
7226 tool_basename="${tool_specified##*/}"
7227 if test "x$tool_basename" = "x$tool_specified"; then
7228 # A command without a complete path is provided, search $PATH.
7229 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7230 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7231 # Extract the first word of "$tool_basename", so it can be a program name with args.
7232 set dummy $tool_basename; ac_word=$2
7233 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7234 $as_echo_n "checking for $ac_word... " >&6; }
7235 if ${ac_cv_path_FIND+:} false; then :
7236 $as_echo_n "(cached) " >&6
7237 else
7238 case $FIND in
7239 [\\/]* | ?:[\\/]*)
7240 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7241 ;;
7242 *)
7243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7244 for as_dir in $PATH
7245 do
7246 IFS=$as_save_IFS
7247 test -z "$as_dir" && as_dir=.
7248 for ac_exec_ext in '' $ac_executable_extensions; do
7249 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7250 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7251 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7252 break 2
7253 fi
7254 done
7255 done
7256 IFS=$as_save_IFS
7257
7258 ;;
7259 esac
7260 fi
7261 FIND=$ac_cv_path_FIND
7262 if test -n "$FIND"; then
7263 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7264 $as_echo "$FIND" >&6; }
7265 else
7266 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7267 $as_echo "no" >&6; }
7268 fi
7269
7270
7271 if test "x$FIND" = x; then
7272 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7273 fi
7274 else
7275 # Otherwise we believe it is a complete path. Use it as it is.
7276 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7277 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7278 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7279 $as_echo_n "checking for FIND... " >&6; }
7280 if test ! -x "$tool_specified"; then
7281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7282 $as_echo "not found" >&6; }
7283 as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7284 fi
7285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7286 $as_echo "$tool_specified" >&6; }
7287 fi
7288 fi
7289 fi
7290
7291
7292
7293 if test "x$FIND" = x; then
7294 as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7295 fi
7296
7297
7298
7299
7300
7301 # Publish this variable in the help.
7302
7303
7304 if test "x$HEAD" = x; then
7305 # The variable is not set by user, try to locate tool using the code snippet
7306 for ac_prog in head
7307 do
7308 # Extract the first word of "$ac_prog", so it can be a program name with args.
7309 set dummy $ac_prog; ac_word=$2
7310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7311 $as_echo_n "checking for $ac_word... " >&6; }
7312 if ${ac_cv_path_HEAD+:} false; then :
7313 $as_echo_n "(cached) " >&6
7314 else
7315 case $HEAD in
7316 [\\/]* | ?:[\\/]*)
7317 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7318 ;;
7319 *)
7320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7321 for as_dir in $PATH
7322 do
7323 IFS=$as_save_IFS
7324 test -z "$as_dir" && as_dir=.
7325 for ac_exec_ext in '' $ac_executable_extensions; do
7326 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7327 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7328 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7329 break 2
7330 fi
7331 done
7332 done
7333 IFS=$as_save_IFS
7334
7335 ;;
7336 esac
7337 fi
7338 HEAD=$ac_cv_path_HEAD
7339 if test -n "$HEAD"; then
7340 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7341 $as_echo "$HEAD" >&6; }
7342 else
7343 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7344 $as_echo "no" >&6; }
7345 fi
7346
7347
7348 test -n "$HEAD" && break
7349 done
7350
7351 else
7352 # The variable is set, but is it from the command line or the environment?
7353
7354 # Try to remove the string !HEAD! from our list.
7355 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7356 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7357 # If it failed, the variable was not from the command line. Ignore it,
7358 # but warn the user (except for BASH, which is always set by the calling BASH).
7359 if test "xHEAD" != xBASH; then
7360 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7361 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7362 fi
7363 # Try to locate tool using the code snippet
7364 for ac_prog in head
7365 do
7366 # Extract the first word of "$ac_prog", so it can be a program name with args.
7367 set dummy $ac_prog; ac_word=$2
7368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7369 $as_echo_n "checking for $ac_word... " >&6; }
7370 if ${ac_cv_path_HEAD+:} false; then :
7371 $as_echo_n "(cached) " >&6
7372 else
7373 case $HEAD in
7374 [\\/]* | ?:[\\/]*)
7375 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7376 ;;
7377 *)
7378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7379 for as_dir in $PATH
7380 do
7381 IFS=$as_save_IFS
7382 test -z "$as_dir" && as_dir=.
7383 for ac_exec_ext in '' $ac_executable_extensions; do
7384 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7385 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7386 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7387 break 2
7388 fi
7389 done
7390 done
7391 IFS=$as_save_IFS
7392
7393 ;;
7394 esac
7395 fi
7396 HEAD=$ac_cv_path_HEAD
7397 if test -n "$HEAD"; then
7398 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7399 $as_echo "$HEAD" >&6; }
7400 else
7401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7402 $as_echo "no" >&6; }
7403 fi
7404
7405
7406 test -n "$HEAD" && break
7407 done
7408
7409 else
7410 # If it succeeded, then it was overridden by the user. We will use it
7411 # for the tool.
7412
7413 # First remove it from the list of overridden variables, so we can test
7414 # for unknown variables in the end.
7415 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7416
7417 # Check if the provided tool contains a complete path.
7418 tool_specified="$HEAD"
7419 tool_basename="${tool_specified##*/}"
7420 if test "x$tool_basename" = "x$tool_specified"; then
7421 # A command without a complete path is provided, search $PATH.
7422 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7423 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7424 # Extract the first word of "$tool_basename", so it can be a program name with args.
7425 set dummy $tool_basename; ac_word=$2
7426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7427 $as_echo_n "checking for $ac_word... " >&6; }
7428 if ${ac_cv_path_HEAD+:} false; then :
7429 $as_echo_n "(cached) " >&6
7430 else
7431 case $HEAD in
7432 [\\/]* | ?:[\\/]*)
7433 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7434 ;;
7435 *)
7436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7437 for as_dir in $PATH
7438 do
7439 IFS=$as_save_IFS
7440 test -z "$as_dir" && as_dir=.
7441 for ac_exec_ext in '' $ac_executable_extensions; do
7442 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7443 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7444 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7445 break 2
7446 fi
7447 done
7448 done
7449 IFS=$as_save_IFS
7450
7451 ;;
7452 esac
7453 fi
7454 HEAD=$ac_cv_path_HEAD
7455 if test -n "$HEAD"; then
7456 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7457 $as_echo "$HEAD" >&6; }
7458 else
7459 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7460 $as_echo "no" >&6; }
7461 fi
7462
7463
7464 if test "x$HEAD" = x; then
7465 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7466 fi
7467 else
7468 # Otherwise we believe it is a complete path. Use it as it is.
7469 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7470 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7471 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7472 $as_echo_n "checking for HEAD... " >&6; }
7473 if test ! -x "$tool_specified"; then
7474 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7475 $as_echo "not found" >&6; }
7476 as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7477 fi
7478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7479 $as_echo "$tool_specified" >&6; }
7480 fi
7481 fi
7482 fi
7483
7484
7485
7486 if test "x$HEAD" = x; then
7487 as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7488 fi
7489
7490
7491
7492
7493
7494 # Publish this variable in the help.
7495
7496
7497 if test "x$LN" = x; then
7498 # The variable is not set by user, try to locate tool using the code snippet
7499 for ac_prog in ln
7500 do
7501 # Extract the first word of "$ac_prog", so it can be a program name with args.
7502 set dummy $ac_prog; ac_word=$2
7503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7504 $as_echo_n "checking for $ac_word... " >&6; }
7505 if ${ac_cv_path_LN+:} false; then :
7506 $as_echo_n "(cached) " >&6
7507 else
7508 case $LN in
7509 [\\/]* | ?:[\\/]*)
7510 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7511 ;;
7512 *)
7513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7514 for as_dir in $PATH
7515 do
7516 IFS=$as_save_IFS
7517 test -z "$as_dir" && as_dir=.
7518 for ac_exec_ext in '' $ac_executable_extensions; do
7519 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7520 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7521 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7522 break 2
7523 fi
7524 done
7525 done
7526 IFS=$as_save_IFS
7527
7528 ;;
7529 esac
7530 fi
7531 LN=$ac_cv_path_LN
7532 if test -n "$LN"; then
7533 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7534 $as_echo "$LN" >&6; }
7535 else
7536 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7537 $as_echo "no" >&6; }
7538 fi
7539
7540
7541 test -n "$LN" && break
7542 done
7543
7544 else
7545 # The variable is set, but is it from the command line or the environment?
7546
7547 # Try to remove the string !LN! from our list.
7548 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7549 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7550 # If it failed, the variable was not from the command line. Ignore it,
7551 # but warn the user (except for BASH, which is always set by the calling BASH).
7552 if test "xLN" != xBASH; then
7553 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7554 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7555 fi
7556 # Try to locate tool using the code snippet
7557 for ac_prog in ln
7558 do
7559 # Extract the first word of "$ac_prog", so it can be a program name with args.
7560 set dummy $ac_prog; ac_word=$2
7561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7562 $as_echo_n "checking for $ac_word... " >&6; }
7563 if ${ac_cv_path_LN+:} false; then :
7564 $as_echo_n "(cached) " >&6
7565 else
7566 case $LN in
7567 [\\/]* | ?:[\\/]*)
7568 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7569 ;;
7570 *)
7571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7572 for as_dir in $PATH
7573 do
7574 IFS=$as_save_IFS
7575 test -z "$as_dir" && as_dir=.
7576 for ac_exec_ext in '' $ac_executable_extensions; do
7577 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7578 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7579 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7580 break 2
7581 fi
7582 done
7583 done
7584 IFS=$as_save_IFS
7585
7586 ;;
7587 esac
7588 fi
7589 LN=$ac_cv_path_LN
7590 if test -n "$LN"; then
7591 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7592 $as_echo "$LN" >&6; }
7593 else
7594 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7595 $as_echo "no" >&6; }
7596 fi
7597
7598
7599 test -n "$LN" && break
7600 done
7601
7602 else
7603 # If it succeeded, then it was overridden by the user. We will use it
7604 # for the tool.
7605
7606 # First remove it from the list of overridden variables, so we can test
7607 # for unknown variables in the end.
7608 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7609
7610 # Check if the provided tool contains a complete path.
7611 tool_specified="$LN"
7612 tool_basename="${tool_specified##*/}"
7613 if test "x$tool_basename" = "x$tool_specified"; then
7614 # A command without a complete path is provided, search $PATH.
7615 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7616 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7617 # Extract the first word of "$tool_basename", so it can be a program name with args.
7618 set dummy $tool_basename; ac_word=$2
7619 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7620 $as_echo_n "checking for $ac_word... " >&6; }
7621 if ${ac_cv_path_LN+:} false; then :
7622 $as_echo_n "(cached) " >&6
7623 else
7624 case $LN in
7625 [\\/]* | ?:[\\/]*)
7626 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7627 ;;
7628 *)
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632 IFS=$as_save_IFS
7633 test -z "$as_dir" && as_dir=.
7634 for ac_exec_ext in '' $ac_executable_extensions; do
7635 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7637 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7638 break 2
7639 fi
7640 done
7641 done
7642 IFS=$as_save_IFS
7643
7644 ;;
7645 esac
7646 fi
7647 LN=$ac_cv_path_LN
7648 if test -n "$LN"; then
7649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7650 $as_echo "$LN" >&6; }
7651 else
7652 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7653 $as_echo "no" >&6; }
7654 fi
7655
7656
7657 if test "x$LN" = x; then
7658 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7659 fi
7660 else
7661 # Otherwise we believe it is a complete path. Use it as it is.
7662 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7663 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7664 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7665 $as_echo_n "checking for LN... " >&6; }
7666 if test ! -x "$tool_specified"; then
7667 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7668 $as_echo "not found" >&6; }
7669 as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7670 fi
7671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7672 $as_echo "$tool_specified" >&6; }
7673 fi
7674 fi
7675 fi
7676
7677
7678
7679 if test "x$LN" = x; then
7680 as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7681 fi
7682
7683
7684
7685
7686
7687 # Publish this variable in the help.
7688
7689
7690 if test "x$LS" = x; then
7691 # The variable is not set by user, try to locate tool using the code snippet
7692 for ac_prog in ls
7693 do
7694 # Extract the first word of "$ac_prog", so it can be a program name with args.
7695 set dummy $ac_prog; ac_word=$2
7696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7697 $as_echo_n "checking for $ac_word... " >&6; }
7698 if ${ac_cv_path_LS+:} false; then :
7699 $as_echo_n "(cached) " >&6
7700 else
7701 case $LS in
7702 [\\/]* | ?:[\\/]*)
7703 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7704 ;;
7705 *)
7706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7707 for as_dir in $PATH
7708 do
7709 IFS=$as_save_IFS
7710 test -z "$as_dir" && as_dir=.
7711 for ac_exec_ext in '' $ac_executable_extensions; do
7712 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7713 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7714 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7715 break 2
7716 fi
7717 done
7718 done
7719 IFS=$as_save_IFS
7720
7721 ;;
7722 esac
7723 fi
7724 LS=$ac_cv_path_LS
7725 if test -n "$LS"; then
7726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7727 $as_echo "$LS" >&6; }
7728 else
7729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7730 $as_echo "no" >&6; }
7731 fi
7732
7733
7734 test -n "$LS" && break
7735 done
7736
7737 else
7738 # The variable is set, but is it from the command line or the environment?
7739
7740 # Try to remove the string !LS! from our list.
7741 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7742 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7743 # If it failed, the variable was not from the command line. Ignore it,
7744 # but warn the user (except for BASH, which is always set by the calling BASH).
7745 if test "xLS" != xBASH; then
7746 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7747 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7748 fi
7749 # Try to locate tool using the code snippet
7750 for ac_prog in ls
7751 do
7752 # Extract the first word of "$ac_prog", so it can be a program name with args.
7753 set dummy $ac_prog; ac_word=$2
7754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7755 $as_echo_n "checking for $ac_word... " >&6; }
7756 if ${ac_cv_path_LS+:} false; then :
7757 $as_echo_n "(cached) " >&6
7758 else
7759 case $LS in
7760 [\\/]* | ?:[\\/]*)
7761 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7762 ;;
7763 *)
7764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7765 for as_dir in $PATH
7766 do
7767 IFS=$as_save_IFS
7768 test -z "$as_dir" && as_dir=.
7769 for ac_exec_ext in '' $ac_executable_extensions; do
7770 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7771 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7772 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7773 break 2
7774 fi
7775 done
7776 done
7777 IFS=$as_save_IFS
7778
7779 ;;
7780 esac
7781 fi
7782 LS=$ac_cv_path_LS
7783 if test -n "$LS"; then
7784 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7785 $as_echo "$LS" >&6; }
7786 else
7787 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7788 $as_echo "no" >&6; }
7789 fi
7790
7791
7792 test -n "$LS" && break
7793 done
7794
7795 else
7796 # If it succeeded, then it was overridden by the user. We will use it
7797 # for the tool.
7798
7799 # First remove it from the list of overridden variables, so we can test
7800 # for unknown variables in the end.
7801 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7802
7803 # Check if the provided tool contains a complete path.
7804 tool_specified="$LS"
7805 tool_basename="${tool_specified##*/}"
7806 if test "x$tool_basename" = "x$tool_specified"; then
7807 # A command without a complete path is provided, search $PATH.
7808 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7809 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7810 # Extract the first word of "$tool_basename", so it can be a program name with args.
7811 set dummy $tool_basename; ac_word=$2
7812 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7813 $as_echo_n "checking for $ac_word... " >&6; }
7814 if ${ac_cv_path_LS+:} false; then :
7815 $as_echo_n "(cached) " >&6
7816 else
7817 case $LS in
7818 [\\/]* | ?:[\\/]*)
7819 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7820 ;;
7821 *)
7822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7823 for as_dir in $PATH
7824 do
7825 IFS=$as_save_IFS
7826 test -z "$as_dir" && as_dir=.
7827 for ac_exec_ext in '' $ac_executable_extensions; do
7828 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7829 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7830 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7831 break 2
7832 fi
7833 done
7834 done
7835 IFS=$as_save_IFS
7836
7837 ;;
7838 esac
7839 fi
7840 LS=$ac_cv_path_LS
7841 if test -n "$LS"; then
7842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7843 $as_echo "$LS" >&6; }
7844 else
7845 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7846 $as_echo "no" >&6; }
7847 fi
7848
7849
7850 if test "x$LS" = x; then
7851 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7852 fi
7853 else
7854 # Otherwise we believe it is a complete path. Use it as it is.
7855 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7856 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7857 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7858 $as_echo_n "checking for LS... " >&6; }
7859 if test ! -x "$tool_specified"; then
7860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7861 $as_echo "not found" >&6; }
7862 as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7863 fi
7864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7865 $as_echo "$tool_specified" >&6; }
7866 fi
7867 fi
7868 fi
7869
7870
7871
7872 if test "x$LS" = x; then
7873 as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7874 fi
7875
7876
7877
7878
7879
7880 # Publish this variable in the help.
7881
7882
7883 if test "x$MKDIR" = x; then
7884 # The variable is not set by user, try to locate tool using the code snippet
7885 for ac_prog in mkdir
7886 do
7887 # Extract the first word of "$ac_prog", so it can be a program name with args.
7888 set dummy $ac_prog; ac_word=$2
7889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7890 $as_echo_n "checking for $ac_word... " >&6; }
7891 if ${ac_cv_path_MKDIR+:} false; then :
7892 $as_echo_n "(cached) " >&6
7893 else
7894 case $MKDIR in
7895 [\\/]* | ?:[\\/]*)
7896 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7897 ;;
7898 *)
7899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7900 for as_dir in $PATH
7901 do
7902 IFS=$as_save_IFS
7903 test -z "$as_dir" && as_dir=.
7904 for ac_exec_ext in '' $ac_executable_extensions; do
7905 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7906 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7907 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7908 break 2
7909 fi
7910 done
7911 done
7912 IFS=$as_save_IFS
7913
7914 ;;
7915 esac
7916 fi
7917 MKDIR=$ac_cv_path_MKDIR
7918 if test -n "$MKDIR"; then
7919 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7920 $as_echo "$MKDIR" >&6; }
7921 else
7922 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7923 $as_echo "no" >&6; }
7924 fi
7925
7926
7927 test -n "$MKDIR" && break
7928 done
7929
7930 else
7931 # The variable is set, but is it from the command line or the environment?
7932
7933 # Try to remove the string !MKDIR! from our list.
7934 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7935 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7936 # If it failed, the variable was not from the command line. Ignore it,
7937 # but warn the user (except for BASH, which is always set by the calling BASH).
7938 if test "xMKDIR" != xBASH; then
7939 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7940 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7941 fi
7942 # Try to locate tool using the code snippet
7943 for ac_prog in mkdir
7944 do
7945 # Extract the first word of "$ac_prog", so it can be a program name with args.
7946 set dummy $ac_prog; ac_word=$2
7947 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7948 $as_echo_n "checking for $ac_word... " >&6; }
7949 if ${ac_cv_path_MKDIR+:} false; then :
7950 $as_echo_n "(cached) " >&6
7951 else
7952 case $MKDIR in
7953 [\\/]* | ?:[\\/]*)
7954 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7955 ;;
7956 *)
7957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7958 for as_dir in $PATH
7959 do
7960 IFS=$as_save_IFS
7961 test -z "$as_dir" && as_dir=.
7962 for ac_exec_ext in '' $ac_executable_extensions; do
7963 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7964 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7965 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7966 break 2
7967 fi
7968 done
7969 done
7970 IFS=$as_save_IFS
7971
7972 ;;
7973 esac
7974 fi
7975 MKDIR=$ac_cv_path_MKDIR
7976 if test -n "$MKDIR"; then
7977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7978 $as_echo "$MKDIR" >&6; }
7979 else
7980 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7981 $as_echo "no" >&6; }
7982 fi
7983
7984
7985 test -n "$MKDIR" && break
7986 done
7987
7988 else
7989 # If it succeeded, then it was overridden by the user. We will use it
7990 # for the tool.
7991
7992 # First remove it from the list of overridden variables, so we can test
7993 # for unknown variables in the end.
7994 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7995
7996 # Check if the provided tool contains a complete path.
7997 tool_specified="$MKDIR"
7998 tool_basename="${tool_specified##*/}"
7999 if test "x$tool_basename" = "x$tool_specified"; then
8000 # A command without a complete path is provided, search $PATH.
8001 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8002 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8003 # Extract the first word of "$tool_basename", so it can be a program name with args.
8004 set dummy $tool_basename; ac_word=$2
8005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8006 $as_echo_n "checking for $ac_word... " >&6; }
8007 if ${ac_cv_path_MKDIR+:} false; then :
8008 $as_echo_n "(cached) " >&6
8009 else
8010 case $MKDIR in
8011 [\\/]* | ?:[\\/]*)
8012 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8013 ;;
8014 *)
8015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8016 for as_dir in $PATH
8017 do
8018 IFS=$as_save_IFS
8019 test -z "$as_dir" && as_dir=.
8020 for ac_exec_ext in '' $ac_executable_extensions; do
8021 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8022 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8023 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8024 break 2
8025 fi
8026 done
8027 done
8028 IFS=$as_save_IFS
8029
8030 ;;
8031 esac
8032 fi
8033 MKDIR=$ac_cv_path_MKDIR
8034 if test -n "$MKDIR"; then
8035 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8036 $as_echo "$MKDIR" >&6; }
8037 else
8038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8039 $as_echo "no" >&6; }
8040 fi
8041
8042
8043 if test "x$MKDIR" = x; then
8044 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8045 fi
8046 else
8047 # Otherwise we believe it is a complete path. Use it as it is.
8048 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8049 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8050 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8051 $as_echo_n "checking for MKDIR... " >&6; }
8052 if test ! -x "$tool_specified"; then
8053 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8054 $as_echo "not found" >&6; }
8055 as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8056 fi
8057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8058 $as_echo "$tool_specified" >&6; }
8059 fi
8060 fi
8061 fi
8062
8063
8064
8065 if test "x$MKDIR" = x; then
8066 as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8067 fi
8068
8069
8070
8071
8072
8073 # Publish this variable in the help.
8074
8075
8076 if test "x$MKTEMP" = x; then
8077 # The variable is not set by user, try to locate tool using the code snippet
8078 for ac_prog in mktemp
8079 do
8080 # Extract the first word of "$ac_prog", so it can be a program name with args.
8081 set dummy $ac_prog; ac_word=$2
8082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8083 $as_echo_n "checking for $ac_word... " >&6; }
8084 if ${ac_cv_path_MKTEMP+:} false; then :
8085 $as_echo_n "(cached) " >&6
8086 else
8087 case $MKTEMP in
8088 [\\/]* | ?:[\\/]*)
8089 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8090 ;;
8091 *)
8092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8093 for as_dir in $PATH
8094 do
8095 IFS=$as_save_IFS
8096 test -z "$as_dir" && as_dir=.
8097 for ac_exec_ext in '' $ac_executable_extensions; do
8098 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8099 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8100 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8101 break 2
8102 fi
8103 done
8104 done
8105 IFS=$as_save_IFS
8106
8107 ;;
8108 esac
8109 fi
8110 MKTEMP=$ac_cv_path_MKTEMP
8111 if test -n "$MKTEMP"; then
8112 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8113 $as_echo "$MKTEMP" >&6; }
8114 else
8115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8116 $as_echo "no" >&6; }
8117 fi
8118
8119
8120 test -n "$MKTEMP" && break
8121 done
8122
8123 else
8124 # The variable is set, but is it from the command line or the environment?
8125
8126 # Try to remove the string !MKTEMP! from our list.
8127 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8128 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8129 # If it failed, the variable was not from the command line. Ignore it,
8130 # but warn the user (except for BASH, which is always set by the calling BASH).
8131 if test "xMKTEMP" != xBASH; then
8132 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8133 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8134 fi
8135 # Try to locate tool using the code snippet
8136 for ac_prog in mktemp
8137 do
8138 # Extract the first word of "$ac_prog", so it can be a program name with args.
8139 set dummy $ac_prog; ac_word=$2
8140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8141 $as_echo_n "checking for $ac_word... " >&6; }
8142 if ${ac_cv_path_MKTEMP+:} false; then :
8143 $as_echo_n "(cached) " >&6
8144 else
8145 case $MKTEMP in
8146 [\\/]* | ?:[\\/]*)
8147 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8148 ;;
8149 *)
8150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8151 for as_dir in $PATH
8152 do
8153 IFS=$as_save_IFS
8154 test -z "$as_dir" && as_dir=.
8155 for ac_exec_ext in '' $ac_executable_extensions; do
8156 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8157 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8158 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8159 break 2
8160 fi
8161 done
8162 done
8163 IFS=$as_save_IFS
8164
8165 ;;
8166 esac
8167 fi
8168 MKTEMP=$ac_cv_path_MKTEMP
8169 if test -n "$MKTEMP"; then
8170 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8171 $as_echo "$MKTEMP" >&6; }
8172 else
8173 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8174 $as_echo "no" >&6; }
8175 fi
8176
8177
8178 test -n "$MKTEMP" && break
8179 done
8180
8181 else
8182 # If it succeeded, then it was overridden by the user. We will use it
8183 # for the tool.
8184
8185 # First remove it from the list of overridden variables, so we can test
8186 # for unknown variables in the end.
8187 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8188
8189 # Check if the provided tool contains a complete path.
8190 tool_specified="$MKTEMP"
8191 tool_basename="${tool_specified##*/}"
8192 if test "x$tool_basename" = "x$tool_specified"; then
8193 # A command without a complete path is provided, search $PATH.
8194 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8195 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8196 # Extract the first word of "$tool_basename", so it can be a program name with args.
8197 set dummy $tool_basename; ac_word=$2
8198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8199 $as_echo_n "checking for $ac_word... " >&6; }
8200 if ${ac_cv_path_MKTEMP+:} false; then :
8201 $as_echo_n "(cached) " >&6
8202 else
8203 case $MKTEMP in
8204 [\\/]* | ?:[\\/]*)
8205 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8206 ;;
8207 *)
8208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8209 for as_dir in $PATH
8210 do
8211 IFS=$as_save_IFS
8212 test -z "$as_dir" && as_dir=.
8213 for ac_exec_ext in '' $ac_executable_extensions; do
8214 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8215 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8216 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8217 break 2
8218 fi
8219 done
8220 done
8221 IFS=$as_save_IFS
8222
8223 ;;
8224 esac
8225 fi
8226 MKTEMP=$ac_cv_path_MKTEMP
8227 if test -n "$MKTEMP"; then
8228 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8229 $as_echo "$MKTEMP" >&6; }
8230 else
8231 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8232 $as_echo "no" >&6; }
8233 fi
8234
8235
8236 if test "x$MKTEMP" = x; then
8237 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8238 fi
8239 else
8240 # Otherwise we believe it is a complete path. Use it as it is.
8241 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8242 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8244 $as_echo_n "checking for MKTEMP... " >&6; }
8245 if test ! -x "$tool_specified"; then
8246 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8247 $as_echo "not found" >&6; }
8248 as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8249 fi
8250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8251 $as_echo "$tool_specified" >&6; }
8252 fi
8253 fi
8254 fi
8255
8256
8257
8258 if test "x$MKTEMP" = x; then
8259 as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8260 fi
8261
8262
8263
8264
8265
8266 # Publish this variable in the help.
8267
8268
8269 if test "x$MV" = x; then
8270 # The variable is not set by user, try to locate tool using the code snippet
8271 for ac_prog in mv
8272 do
8273 # Extract the first word of "$ac_prog", so it can be a program name with args.
8274 set dummy $ac_prog; ac_word=$2
8275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8276 $as_echo_n "checking for $ac_word... " >&6; }
8277 if ${ac_cv_path_MV+:} false; then :
8278 $as_echo_n "(cached) " >&6
8279 else
8280 case $MV in
8281 [\\/]* | ?:[\\/]*)
8282 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8283 ;;
8284 *)
8285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8286 for as_dir in $PATH
8287 do
8288 IFS=$as_save_IFS
8289 test -z "$as_dir" && as_dir=.
8290 for ac_exec_ext in '' $ac_executable_extensions; do
8291 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8292 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8293 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8294 break 2
8295 fi
8296 done
8297 done
8298 IFS=$as_save_IFS
8299
8300 ;;
8301 esac
8302 fi
8303 MV=$ac_cv_path_MV
8304 if test -n "$MV"; then
8305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8306 $as_echo "$MV" >&6; }
8307 else
8308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8309 $as_echo "no" >&6; }
8310 fi
8311
8312
8313 test -n "$MV" && break
8314 done
8315
8316 else
8317 # The variable is set, but is it from the command line or the environment?
8318
8319 # Try to remove the string !MV! from our list.
8320 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8321 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8322 # If it failed, the variable was not from the command line. Ignore it,
8323 # but warn the user (except for BASH, which is always set by the calling BASH).
8324 if test "xMV" != xBASH; then
8325 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8326 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8327 fi
8328 # Try to locate tool using the code snippet
8329 for ac_prog in mv
8330 do
8331 # Extract the first word of "$ac_prog", so it can be a program name with args.
8332 set dummy $ac_prog; ac_word=$2
8333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8334 $as_echo_n "checking for $ac_word... " >&6; }
8335 if ${ac_cv_path_MV+:} false; then :
8336 $as_echo_n "(cached) " >&6
8337 else
8338 case $MV in
8339 [\\/]* | ?:[\\/]*)
8340 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8341 ;;
8342 *)
8343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8344 for as_dir in $PATH
8345 do
8346 IFS=$as_save_IFS
8347 test -z "$as_dir" && as_dir=.
8348 for ac_exec_ext in '' $ac_executable_extensions; do
8349 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8350 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8351 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8352 break 2
8353 fi
8354 done
8355 done
8356 IFS=$as_save_IFS
8357
8358 ;;
8359 esac
8360 fi
8361 MV=$ac_cv_path_MV
8362 if test -n "$MV"; then
8363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8364 $as_echo "$MV" >&6; }
8365 else
8366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8367 $as_echo "no" >&6; }
8368 fi
8369
8370
8371 test -n "$MV" && break
8372 done
8373
8374 else
8375 # If it succeeded, then it was overridden by the user. We will use it
8376 # for the tool.
8377
8378 # First remove it from the list of overridden variables, so we can test
8379 # for unknown variables in the end.
8380 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8381
8382 # Check if the provided tool contains a complete path.
8383 tool_specified="$MV"
8384 tool_basename="${tool_specified##*/}"
8385 if test "x$tool_basename" = "x$tool_specified"; then
8386 # A command without a complete path is provided, search $PATH.
8387 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8388 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8389 # Extract the first word of "$tool_basename", so it can be a program name with args.
8390 set dummy $tool_basename; ac_word=$2
8391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8392 $as_echo_n "checking for $ac_word... " >&6; }
8393 if ${ac_cv_path_MV+:} false; then :
8394 $as_echo_n "(cached) " >&6
8395 else
8396 case $MV in
8397 [\\/]* | ?:[\\/]*)
8398 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8399 ;;
8400 *)
8401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8402 for as_dir in $PATH
8403 do
8404 IFS=$as_save_IFS
8405 test -z "$as_dir" && as_dir=.
8406 for ac_exec_ext in '' $ac_executable_extensions; do
8407 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8408 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8409 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8410 break 2
8411 fi
8412 done
8413 done
8414 IFS=$as_save_IFS
8415
8416 ;;
8417 esac
8418 fi
8419 MV=$ac_cv_path_MV
8420 if test -n "$MV"; then
8421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8422 $as_echo "$MV" >&6; }
8423 else
8424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8425 $as_echo "no" >&6; }
8426 fi
8427
8428
8429 if test "x$MV" = x; then
8430 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8431 fi
8432 else
8433 # Otherwise we believe it is a complete path. Use it as it is.
8434 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8435 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8437 $as_echo_n "checking for MV... " >&6; }
8438 if test ! -x "$tool_specified"; then
8439 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8440 $as_echo "not found" >&6; }
8441 as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8442 fi
8443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8444 $as_echo "$tool_specified" >&6; }
8445 fi
8446 fi
8447 fi
8448
8449
8450
8451 if test "x$MV" = x; then
8452 as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8453 fi
8454
8455
8456
8457
8458
8459 # Publish this variable in the help.
8460
8461
8462 if test "x$NAWK" = x; then
8463 # The variable is not set by user, try to locate tool using the code snippet
8464 for ac_prog in nawk gawk awk
8465 do
8466 # Extract the first word of "$ac_prog", so it can be a program name with args.
8467 set dummy $ac_prog; ac_word=$2
8468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8469 $as_echo_n "checking for $ac_word... " >&6; }
8470 if ${ac_cv_path_NAWK+:} false; then :
8471 $as_echo_n "(cached) " >&6
8472 else
8473 case $NAWK in
8474 [\\/]* | ?:[\\/]*)
8475 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8476 ;;
8477 *)
8478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8479 for as_dir in $PATH
8480 do
8481 IFS=$as_save_IFS
8482 test -z "$as_dir" && as_dir=.
8483 for ac_exec_ext in '' $ac_executable_extensions; do
8484 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8485 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8486 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8487 break 2
8488 fi
8489 done
8490 done
8491 IFS=$as_save_IFS
8492
8493 ;;
8494 esac
8495 fi
8496 NAWK=$ac_cv_path_NAWK
8497 if test -n "$NAWK"; then
8498 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8499 $as_echo "$NAWK" >&6; }
8500 else
8501 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8502 $as_echo "no" >&6; }
8503 fi
8504
8505
8506 test -n "$NAWK" && break
8507 done
8508
8509 else
8510 # The variable is set, but is it from the command line or the environment?
8511
8512 # Try to remove the string !NAWK! from our list.
8513 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8514 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8515 # If it failed, the variable was not from the command line. Ignore it,
8516 # but warn the user (except for BASH, which is always set by the calling BASH).
8517 if test "xNAWK" != xBASH; then
8518 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8519 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8520 fi
8521 # Try to locate tool using the code snippet
8522 for ac_prog in nawk gawk awk
8523 do
8524 # Extract the first word of "$ac_prog", so it can be a program name with args.
8525 set dummy $ac_prog; ac_word=$2
8526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8527 $as_echo_n "checking for $ac_word... " >&6; }
8528 if ${ac_cv_path_NAWK+:} false; then :
8529 $as_echo_n "(cached) " >&6
8530 else
8531 case $NAWK in
8532 [\\/]* | ?:[\\/]*)
8533 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8534 ;;
8535 *)
8536 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8537 for as_dir in $PATH
8538 do
8539 IFS=$as_save_IFS
8540 test -z "$as_dir" && as_dir=.
8541 for ac_exec_ext in '' $ac_executable_extensions; do
8542 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8543 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8544 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8545 break 2
8546 fi
8547 done
8548 done
8549 IFS=$as_save_IFS
8550
8551 ;;
8552 esac
8553 fi
8554 NAWK=$ac_cv_path_NAWK
8555 if test -n "$NAWK"; then
8556 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8557 $as_echo "$NAWK" >&6; }
8558 else
8559 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8560 $as_echo "no" >&6; }
8561 fi
8562
8563
8564 test -n "$NAWK" && break
8565 done
8566
8567 else
8568 # If it succeeded, then it was overridden by the user. We will use it
8569 # for the tool.
8570
8571 # First remove it from the list of overridden variables, so we can test
8572 # for unknown variables in the end.
8573 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8574
8575 # Check if the provided tool contains a complete path.
8576 tool_specified="$NAWK"
8577 tool_basename="${tool_specified##*/}"
8578 if test "x$tool_basename" = "x$tool_specified"; then
8579 # A command without a complete path is provided, search $PATH.
8580 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8581 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8582 # Extract the first word of "$tool_basename", so it can be a program name with args.
8583 set dummy $tool_basename; ac_word=$2
8584 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8585 $as_echo_n "checking for $ac_word... " >&6; }
8586 if ${ac_cv_path_NAWK+:} false; then :
8587 $as_echo_n "(cached) " >&6
8588 else
8589 case $NAWK in
8590 [\\/]* | ?:[\\/]*)
8591 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8592 ;;
8593 *)
8594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8595 for as_dir in $PATH
8596 do
8597 IFS=$as_save_IFS
8598 test -z "$as_dir" && as_dir=.
8599 for ac_exec_ext in '' $ac_executable_extensions; do
8600 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8601 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8602 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8603 break 2
8604 fi
8605 done
8606 done
8607 IFS=$as_save_IFS
8608
8609 ;;
8610 esac
8611 fi
8612 NAWK=$ac_cv_path_NAWK
8613 if test -n "$NAWK"; then
8614 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8615 $as_echo "$NAWK" >&6; }
8616 else
8617 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8618 $as_echo "no" >&6; }
8619 fi
8620
8621
8622 if test "x$NAWK" = x; then
8623 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8624 fi
8625 else
8626 # Otherwise we believe it is a complete path. Use it as it is.
8627 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8628 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8630 $as_echo_n "checking for NAWK... " >&6; }
8631 if test ! -x "$tool_specified"; then
8632 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8633 $as_echo "not found" >&6; }
8634 as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8635 fi
8636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8637 $as_echo "$tool_specified" >&6; }
8638 fi
8639 fi
8640 fi
8641
8642
8643
8644 if test "x$NAWK" = x; then
8645 as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8646 fi
8647
8648
8649
8650
8651
8652 # Publish this variable in the help.
8653
8654
8655 if test "x$PRINTF" = x; then
8656 # The variable is not set by user, try to locate tool using the code snippet
8657 for ac_prog in printf
8658 do
8659 # Extract the first word of "$ac_prog", so it can be a program name with args.
8660 set dummy $ac_prog; ac_word=$2
8661 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8662 $as_echo_n "checking for $ac_word... " >&6; }
8663 if ${ac_cv_path_PRINTF+:} false; then :
8664 $as_echo_n "(cached) " >&6
8665 else
8666 case $PRINTF in
8667 [\\/]* | ?:[\\/]*)
8668 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8669 ;;
8670 *)
8671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8672 for as_dir in $PATH
8673 do
8674 IFS=$as_save_IFS
8675 test -z "$as_dir" && as_dir=.
8676 for ac_exec_ext in '' $ac_executable_extensions; do
8677 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8678 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8679 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8680 break 2
8681 fi
8682 done
8683 done
8684 IFS=$as_save_IFS
8685
8686 ;;
8687 esac
8688 fi
8689 PRINTF=$ac_cv_path_PRINTF
8690 if test -n "$PRINTF"; then
8691 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8692 $as_echo "$PRINTF" >&6; }
8693 else
8694 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8695 $as_echo "no" >&6; }
8696 fi
8697
8698
8699 test -n "$PRINTF" && break
8700 done
8701
8702 else
8703 # The variable is set, but is it from the command line or the environment?
8704
8705 # Try to remove the string !PRINTF! from our list.
8706 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8707 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8708 # If it failed, the variable was not from the command line. Ignore it,
8709 # but warn the user (except for BASH, which is always set by the calling BASH).
8710 if test "xPRINTF" != xBASH; then
8711 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8712 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8713 fi
8714 # Try to locate tool using the code snippet
8715 for ac_prog in printf
8716 do
8717 # Extract the first word of "$ac_prog", so it can be a program name with args.
8718 set dummy $ac_prog; ac_word=$2
8719 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8720 $as_echo_n "checking for $ac_word... " >&6; }
8721 if ${ac_cv_path_PRINTF+:} false; then :
8722 $as_echo_n "(cached) " >&6
8723 else
8724 case $PRINTF in
8725 [\\/]* | ?:[\\/]*)
8726 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8727 ;;
8728 *)
8729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8730 for as_dir in $PATH
8731 do
8732 IFS=$as_save_IFS
8733 test -z "$as_dir" && as_dir=.
8734 for ac_exec_ext in '' $ac_executable_extensions; do
8735 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8736 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8737 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8738 break 2
8739 fi
8740 done
8741 done
8742 IFS=$as_save_IFS
8743
8744 ;;
8745 esac
8746 fi
8747 PRINTF=$ac_cv_path_PRINTF
8748 if test -n "$PRINTF"; then
8749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8750 $as_echo "$PRINTF" >&6; }
8751 else
8752 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8753 $as_echo "no" >&6; }
8754 fi
8755
8756
8757 test -n "$PRINTF" && break
8758 done
8759
8760 else
8761 # If it succeeded, then it was overridden by the user. We will use it
8762 # for the tool.
8763
8764 # First remove it from the list of overridden variables, so we can test
8765 # for unknown variables in the end.
8766 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8767
8768 # Check if the provided tool contains a complete path.
8769 tool_specified="$PRINTF"
8770 tool_basename="${tool_specified##*/}"
8771 if test "x$tool_basename" = "x$tool_specified"; then
8772 # A command without a complete path is provided, search $PATH.
8773 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8774 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8775 # Extract the first word of "$tool_basename", so it can be a program name with args.
8776 set dummy $tool_basename; ac_word=$2
8777 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8778 $as_echo_n "checking for $ac_word... " >&6; }
8779 if ${ac_cv_path_PRINTF+:} false; then :
8780 $as_echo_n "(cached) " >&6
8781 else
8782 case $PRINTF in
8783 [\\/]* | ?:[\\/]*)
8784 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8785 ;;
8786 *)
8787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8788 for as_dir in $PATH
8789 do
8790 IFS=$as_save_IFS
8791 test -z "$as_dir" && as_dir=.
8792 for ac_exec_ext in '' $ac_executable_extensions; do
8793 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8794 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8795 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8796 break 2
8797 fi
8798 done
8799 done
8800 IFS=$as_save_IFS
8801
8802 ;;
8803 esac
8804 fi
8805 PRINTF=$ac_cv_path_PRINTF
8806 if test -n "$PRINTF"; then
8807 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8808 $as_echo "$PRINTF" >&6; }
8809 else
8810 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8811 $as_echo "no" >&6; }
8812 fi
8813
8814
8815 if test "x$PRINTF" = x; then
8816 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8817 fi
8818 else
8819 # Otherwise we believe it is a complete path. Use it as it is.
8820 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8821 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8822 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8823 $as_echo_n "checking for PRINTF... " >&6; }
8824 if test ! -x "$tool_specified"; then
8825 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8826 $as_echo "not found" >&6; }
8827 as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8828 fi
8829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8830 $as_echo "$tool_specified" >&6; }
8831 fi
8832 fi
8833 fi
8834
8835
8836
8837 if test "x$PRINTF" = x; then
8838 as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8839 fi
8840
8841
8842
8843
8844
8845 # Publish this variable in the help.
8846
8847
8848 if test "x$RM" = x; then
8849 # The variable is not set by user, try to locate tool using the code snippet
8850 for ac_prog in rm
8851 do
8852 # Extract the first word of "$ac_prog", so it can be a program name with args.
8853 set dummy $ac_prog; ac_word=$2
8854 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8855 $as_echo_n "checking for $ac_word... " >&6; }
8856 if ${ac_cv_path_RM+:} false; then :
8857 $as_echo_n "(cached) " >&6
8858 else
8859 case $RM in
8860 [\\/]* | ?:[\\/]*)
8861 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8862 ;;
8863 *)
8864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8865 for as_dir in $PATH
8866 do
8867 IFS=$as_save_IFS
8868 test -z "$as_dir" && as_dir=.
8869 for ac_exec_ext in '' $ac_executable_extensions; do
8870 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8871 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8872 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8873 break 2
8874 fi
8875 done
8876 done
8877 IFS=$as_save_IFS
8878
8879 ;;
8880 esac
8881 fi
8882 RM=$ac_cv_path_RM
8883 if test -n "$RM"; then
8884 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8885 $as_echo "$RM" >&6; }
8886 else
8887 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8888 $as_echo "no" >&6; }
8889 fi
8890
8891
8892 test -n "$RM" && break
8893 done
8894
8895 else
8896 # The variable is set, but is it from the command line or the environment?
8897
8898 # Try to remove the string !RM! from our list.
8899 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8900 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8901 # If it failed, the variable was not from the command line. Ignore it,
8902 # but warn the user (except for BASH, which is always set by the calling BASH).
8903 if test "xRM" != xBASH; then
8904 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8905 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8906 fi
8907 # Try to locate tool using the code snippet
8908 for ac_prog in rm
8909 do
8910 # Extract the first word of "$ac_prog", so it can be a program name with args.
8911 set dummy $ac_prog; ac_word=$2
8912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8913 $as_echo_n "checking for $ac_word... " >&6; }
8914 if ${ac_cv_path_RM+:} false; then :
8915 $as_echo_n "(cached) " >&6
8916 else
8917 case $RM in
8918 [\\/]* | ?:[\\/]*)
8919 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8920 ;;
8921 *)
8922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8923 for as_dir in $PATH
8924 do
8925 IFS=$as_save_IFS
8926 test -z "$as_dir" && as_dir=.
8927 for ac_exec_ext in '' $ac_executable_extensions; do
8928 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8929 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8930 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8931 break 2
8932 fi
8933 done
8934 done
8935 IFS=$as_save_IFS
8936
8937 ;;
8938 esac
8939 fi
8940 RM=$ac_cv_path_RM
8941 if test -n "$RM"; then
8942 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8943 $as_echo "$RM" >&6; }
8944 else
8945 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8946 $as_echo "no" >&6; }
8947 fi
8948
8949
8950 test -n "$RM" && break
8951 done
8952
8953 else
8954 # If it succeeded, then it was overridden by the user. We will use it
8955 # for the tool.
8956
8957 # First remove it from the list of overridden variables, so we can test
8958 # for unknown variables in the end.
8959 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8960
8961 # Check if the provided tool contains a complete path.
8962 tool_specified="$RM"
8963 tool_basename="${tool_specified##*/}"
8964 if test "x$tool_basename" = "x$tool_specified"; then
8965 # A command without a complete path is provided, search $PATH.
8966 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8967 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8968 # Extract the first word of "$tool_basename", so it can be a program name with args.
8969 set dummy $tool_basename; ac_word=$2
8970 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8971 $as_echo_n "checking for $ac_word... " >&6; }
8972 if ${ac_cv_path_RM+:} false; then :
8973 $as_echo_n "(cached) " >&6
8974 else
8975 case $RM in
8976 [\\/]* | ?:[\\/]*)
8977 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8978 ;;
8979 *)
8980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8981 for as_dir in $PATH
8982 do
8983 IFS=$as_save_IFS
8984 test -z "$as_dir" && as_dir=.
8985 for ac_exec_ext in '' $ac_executable_extensions; do
8986 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8987 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8988 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8989 break 2
8990 fi
8991 done
8992 done
8993 IFS=$as_save_IFS
8994
8995 ;;
8996 esac
8997 fi
8998 RM=$ac_cv_path_RM
8999 if test -n "$RM"; then
9000 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9001 $as_echo "$RM" >&6; }
9002 else
9003 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9004 $as_echo "no" >&6; }
9005 fi
9006
9007
9008 if test "x$RM" = x; then
9009 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9010 fi
9011 else
9012 # Otherwise we believe it is a complete path. Use it as it is.
9013 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9014 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9015 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9016 $as_echo_n "checking for RM... " >&6; }
9017 if test ! -x "$tool_specified"; then
9018 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9019 $as_echo "not found" >&6; }
9020 as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9021 fi
9022 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9023 $as_echo "$tool_specified" >&6; }
9024 fi
9025 fi
9026 fi
9027
9028
9029
9030 if test "x$RM" = x; then
9031 as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9032 fi
9033
9034
9035
9036
9037
9038 # Publish this variable in the help.
9039
9040
9041 if test "x$SH" = x; then
9042 # The variable is not set by user, try to locate tool using the code snippet
9043 for ac_prog in sh
9044 do
9045 # Extract the first word of "$ac_prog", so it can be a program name with args.
9046 set dummy $ac_prog; ac_word=$2
9047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9048 $as_echo_n "checking for $ac_word... " >&6; }
9049 if ${ac_cv_path_SH+:} false; then :
9050 $as_echo_n "(cached) " >&6
9051 else
9052 case $SH in
9053 [\\/]* | ?:[\\/]*)
9054 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9055 ;;
9056 *)
9057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9058 for as_dir in $PATH
9059 do
9060 IFS=$as_save_IFS
9061 test -z "$as_dir" && as_dir=.
9062 for ac_exec_ext in '' $ac_executable_extensions; do
9063 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9064 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9065 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9066 break 2
9067 fi
9068 done
9069 done
9070 IFS=$as_save_IFS
9071
9072 ;;
9073 esac
9074 fi
9075 SH=$ac_cv_path_SH
9076 if test -n "$SH"; then
9077 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9078 $as_echo "$SH" >&6; }
9079 else
9080 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9081 $as_echo "no" >&6; }
9082 fi
9083
9084
9085 test -n "$SH" && break
9086 done
9087
9088 else
9089 # The variable is set, but is it from the command line or the environment?
9090
9091 # Try to remove the string !SH! from our list.
9092 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9093 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9094 # If it failed, the variable was not from the command line. Ignore it,
9095 # but warn the user (except for BASH, which is always set by the calling BASH).
9096 if test "xSH" != xBASH; then
9097 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9098 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9099 fi
9100 # Try to locate tool using the code snippet
9101 for ac_prog in sh
9102 do
9103 # Extract the first word of "$ac_prog", so it can be a program name with args.
9104 set dummy $ac_prog; ac_word=$2
9105 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9106 $as_echo_n "checking for $ac_word... " >&6; }
9107 if ${ac_cv_path_SH+:} false; then :
9108 $as_echo_n "(cached) " >&6
9109 else
9110 case $SH in
9111 [\\/]* | ?:[\\/]*)
9112 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9113 ;;
9114 *)
9115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9116 for as_dir in $PATH
9117 do
9118 IFS=$as_save_IFS
9119 test -z "$as_dir" && as_dir=.
9120 for ac_exec_ext in '' $ac_executable_extensions; do
9121 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9122 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9123 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9124 break 2
9125 fi
9126 done
9127 done
9128 IFS=$as_save_IFS
9129
9130 ;;
9131 esac
9132 fi
9133 SH=$ac_cv_path_SH
9134 if test -n "$SH"; then
9135 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9136 $as_echo "$SH" >&6; }
9137 else
9138 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9139 $as_echo "no" >&6; }
9140 fi
9141
9142
9143 test -n "$SH" && break
9144 done
9145
9146 else
9147 # If it succeeded, then it was overridden by the user. We will use it
9148 # for the tool.
9149
9150 # First remove it from the list of overridden variables, so we can test
9151 # for unknown variables in the end.
9152 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9153
9154 # Check if the provided tool contains a complete path.
9155 tool_specified="$SH"
9156 tool_basename="${tool_specified##*/}"
9157 if test "x$tool_basename" = "x$tool_specified"; then
9158 # A command without a complete path is provided, search $PATH.
9159 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9160 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9161 # Extract the first word of "$tool_basename", so it can be a program name with args.
9162 set dummy $tool_basename; ac_word=$2
9163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9164 $as_echo_n "checking for $ac_word... " >&6; }
9165 if ${ac_cv_path_SH+:} false; then :
9166 $as_echo_n "(cached) " >&6
9167 else
9168 case $SH in
9169 [\\/]* | ?:[\\/]*)
9170 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9171 ;;
9172 *)
9173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9174 for as_dir in $PATH
9175 do
9176 IFS=$as_save_IFS
9177 test -z "$as_dir" && as_dir=.
9178 for ac_exec_ext in '' $ac_executable_extensions; do
9179 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9180 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9181 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9182 break 2
9183 fi
9184 done
9185 done
9186 IFS=$as_save_IFS
9187
9188 ;;
9189 esac
9190 fi
9191 SH=$ac_cv_path_SH
9192 if test -n "$SH"; then
9193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9194 $as_echo "$SH" >&6; }
9195 else
9196 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9197 $as_echo "no" >&6; }
9198 fi
9199
9200
9201 if test "x$SH" = x; then
9202 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9203 fi
9204 else
9205 # Otherwise we believe it is a complete path. Use it as it is.
9206 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9207 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9209 $as_echo_n "checking for SH... " >&6; }
9210 if test ! -x "$tool_specified"; then
9211 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9212 $as_echo "not found" >&6; }
9213 as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9214 fi
9215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9216 $as_echo "$tool_specified" >&6; }
9217 fi
9218 fi
9219 fi
9220
9221
9222
9223 if test "x$SH" = x; then
9224 as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9225 fi
9226
9227
9228
9229
9230
9231 # Publish this variable in the help.
9232
9233
9234 if test "x$SORT" = x; then
9235 # The variable is not set by user, try to locate tool using the code snippet
9236 for ac_prog in sort
9237 do
9238 # Extract the first word of "$ac_prog", so it can be a program name with args.
9239 set dummy $ac_prog; ac_word=$2
9240 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9241 $as_echo_n "checking for $ac_word... " >&6; }
9242 if ${ac_cv_path_SORT+:} false; then :
9243 $as_echo_n "(cached) " >&6
9244 else
9245 case $SORT in
9246 [\\/]* | ?:[\\/]*)
9247 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9248 ;;
9249 *)
9250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9251 for as_dir in $PATH
9252 do
9253 IFS=$as_save_IFS
9254 test -z "$as_dir" && as_dir=.
9255 for ac_exec_ext in '' $ac_executable_extensions; do
9256 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9257 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9258 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9259 break 2
9260 fi
9261 done
9262 done
9263 IFS=$as_save_IFS
9264
9265 ;;
9266 esac
9267 fi
9268 SORT=$ac_cv_path_SORT
9269 if test -n "$SORT"; then
9270 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9271 $as_echo "$SORT" >&6; }
9272 else
9273 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9274 $as_echo "no" >&6; }
9275 fi
9276
9277
9278 test -n "$SORT" && break
9279 done
9280
9281 else
9282 # The variable is set, but is it from the command line or the environment?
9283
9284 # Try to remove the string !SORT! from our list.
9285 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9286 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9287 # If it failed, the variable was not from the command line. Ignore it,
9288 # but warn the user (except for BASH, which is always set by the calling BASH).
9289 if test "xSORT" != xBASH; then
9290 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9291 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9292 fi
9293 # Try to locate tool using the code snippet
9294 for ac_prog in sort
9295 do
9296 # Extract the first word of "$ac_prog", so it can be a program name with args.
9297 set dummy $ac_prog; ac_word=$2
9298 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9299 $as_echo_n "checking for $ac_word... " >&6; }
9300 if ${ac_cv_path_SORT+:} false; then :
9301 $as_echo_n "(cached) " >&6
9302 else
9303 case $SORT in
9304 [\\/]* | ?:[\\/]*)
9305 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9306 ;;
9307 *)
9308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9309 for as_dir in $PATH
9310 do
9311 IFS=$as_save_IFS
9312 test -z "$as_dir" && as_dir=.
9313 for ac_exec_ext in '' $ac_executable_extensions; do
9314 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9315 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9316 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9317 break 2
9318 fi
9319 done
9320 done
9321 IFS=$as_save_IFS
9322
9323 ;;
9324 esac
9325 fi
9326 SORT=$ac_cv_path_SORT
9327 if test -n "$SORT"; then
9328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9329 $as_echo "$SORT" >&6; }
9330 else
9331 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9332 $as_echo "no" >&6; }
9333 fi
9334
9335
9336 test -n "$SORT" && break
9337 done
9338
9339 else
9340 # If it succeeded, then it was overridden by the user. We will use it
9341 # for the tool.
9342
9343 # First remove it from the list of overridden variables, so we can test
9344 # for unknown variables in the end.
9345 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9346
9347 # Check if the provided tool contains a complete path.
9348 tool_specified="$SORT"
9349 tool_basename="${tool_specified##*/}"
9350 if test "x$tool_basename" = "x$tool_specified"; then
9351 # A command without a complete path is provided, search $PATH.
9352 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9353 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9354 # Extract the first word of "$tool_basename", so it can be a program name with args.
9355 set dummy $tool_basename; ac_word=$2
9356 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9357 $as_echo_n "checking for $ac_word... " >&6; }
9358 if ${ac_cv_path_SORT+:} false; then :
9359 $as_echo_n "(cached) " >&6
9360 else
9361 case $SORT in
9362 [\\/]* | ?:[\\/]*)
9363 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9364 ;;
9365 *)
9366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9367 for as_dir in $PATH
9368 do
9369 IFS=$as_save_IFS
9370 test -z "$as_dir" && as_dir=.
9371 for ac_exec_ext in '' $ac_executable_extensions; do
9372 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9373 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9374 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9375 break 2
9376 fi
9377 done
9378 done
9379 IFS=$as_save_IFS
9380
9381 ;;
9382 esac
9383 fi
9384 SORT=$ac_cv_path_SORT
9385 if test -n "$SORT"; then
9386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9387 $as_echo "$SORT" >&6; }
9388 else
9389 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9390 $as_echo "no" >&6; }
9391 fi
9392
9393
9394 if test "x$SORT" = x; then
9395 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9396 fi
9397 else
9398 # Otherwise we believe it is a complete path. Use it as it is.
9399 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9400 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9401 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9402 $as_echo_n "checking for SORT... " >&6; }
9403 if test ! -x "$tool_specified"; then
9404 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9405 $as_echo "not found" >&6; }
9406 as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9407 fi
9408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9409 $as_echo "$tool_specified" >&6; }
9410 fi
9411 fi
9412 fi
9413
9414
9415
9416 if test "x$SORT" = x; then
9417 as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9418 fi
9419
9420
9421
9422
9423
9424 # Publish this variable in the help.
9425
9426
9427 if test "x$TAIL" = x; then
9428 # The variable is not set by user, try to locate tool using the code snippet
9429 for ac_prog in tail
9430 do
9431 # Extract the first word of "$ac_prog", so it can be a program name with args.
9432 set dummy $ac_prog; ac_word=$2
9433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9434 $as_echo_n "checking for $ac_word... " >&6; }
9435 if ${ac_cv_path_TAIL+:} false; then :
9436 $as_echo_n "(cached) " >&6
9437 else
9438 case $TAIL in
9439 [\\/]* | ?:[\\/]*)
9440 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9441 ;;
9442 *)
9443 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9444 for as_dir in $PATH
9445 do
9446 IFS=$as_save_IFS
9447 test -z "$as_dir" && as_dir=.
9448 for ac_exec_ext in '' $ac_executable_extensions; do
9449 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9450 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9451 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9452 break 2
9453 fi
9454 done
9455 done
9456 IFS=$as_save_IFS
9457
9458 ;;
9459 esac
9460 fi
9461 TAIL=$ac_cv_path_TAIL
9462 if test -n "$TAIL"; then
9463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9464 $as_echo "$TAIL" >&6; }
9465 else
9466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9467 $as_echo "no" >&6; }
9468 fi
9469
9470
9471 test -n "$TAIL" && break
9472 done
9473
9474 else
9475 # The variable is set, but is it from the command line or the environment?
9476
9477 # Try to remove the string !TAIL! from our list.
9478 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9479 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9480 # If it failed, the variable was not from the command line. Ignore it,
9481 # but warn the user (except for BASH, which is always set by the calling BASH).
9482 if test "xTAIL" != xBASH; then
9483 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9484 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9485 fi
9486 # Try to locate tool using the code snippet
9487 for ac_prog in tail
9488 do
9489 # Extract the first word of "$ac_prog", so it can be a program name with args.
9490 set dummy $ac_prog; ac_word=$2
9491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9492 $as_echo_n "checking for $ac_word... " >&6; }
9493 if ${ac_cv_path_TAIL+:} false; then :
9494 $as_echo_n "(cached) " >&6
9495 else
9496 case $TAIL in
9497 [\\/]* | ?:[\\/]*)
9498 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9499 ;;
9500 *)
9501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9502 for as_dir in $PATH
9503 do
9504 IFS=$as_save_IFS
9505 test -z "$as_dir" && as_dir=.
9506 for ac_exec_ext in '' $ac_executable_extensions; do
9507 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9508 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9509 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9510 break 2
9511 fi
9512 done
9513 done
9514 IFS=$as_save_IFS
9515
9516 ;;
9517 esac
9518 fi
9519 TAIL=$ac_cv_path_TAIL
9520 if test -n "$TAIL"; then
9521 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9522 $as_echo "$TAIL" >&6; }
9523 else
9524 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9525 $as_echo "no" >&6; }
9526 fi
9527
9528
9529 test -n "$TAIL" && break
9530 done
9531
9532 else
9533 # If it succeeded, then it was overridden by the user. We will use it
9534 # for the tool.
9535
9536 # First remove it from the list of overridden variables, so we can test
9537 # for unknown variables in the end.
9538 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9539
9540 # Check if the provided tool contains a complete path.
9541 tool_specified="$TAIL"
9542 tool_basename="${tool_specified##*/}"
9543 if test "x$tool_basename" = "x$tool_specified"; then
9544 # A command without a complete path is provided, search $PATH.
9545 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9546 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9547 # Extract the first word of "$tool_basename", so it can be a program name with args.
9548 set dummy $tool_basename; ac_word=$2
9549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9550 $as_echo_n "checking for $ac_word... " >&6; }
9551 if ${ac_cv_path_TAIL+:} false; then :
9552 $as_echo_n "(cached) " >&6
9553 else
9554 case $TAIL in
9555 [\\/]* | ?:[\\/]*)
9556 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9557 ;;
9558 *)
9559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9560 for as_dir in $PATH
9561 do
9562 IFS=$as_save_IFS
9563 test -z "$as_dir" && as_dir=.
9564 for ac_exec_ext in '' $ac_executable_extensions; do
9565 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9566 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9567 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9568 break 2
9569 fi
9570 done
9571 done
9572 IFS=$as_save_IFS
9573
9574 ;;
9575 esac
9576 fi
9577 TAIL=$ac_cv_path_TAIL
9578 if test -n "$TAIL"; then
9579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9580 $as_echo "$TAIL" >&6; }
9581 else
9582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9583 $as_echo "no" >&6; }
9584 fi
9585
9586
9587 if test "x$TAIL" = x; then
9588 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9589 fi
9590 else
9591 # Otherwise we believe it is a complete path. Use it as it is.
9592 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9593 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9594 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9595 $as_echo_n "checking for TAIL... " >&6; }
9596 if test ! -x "$tool_specified"; then
9597 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9598 $as_echo "not found" >&6; }
9599 as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9600 fi
9601 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9602 $as_echo "$tool_specified" >&6; }
9603 fi
9604 fi
9605 fi
9606
9607
9608
9609 if test "x$TAIL" = x; then
9610 as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9611 fi
9612
9613
9614
9615
9616
9617 # Publish this variable in the help.
9618
9619
9620 if test "x$TAR" = x; then
9621 # The variable is not set by user, try to locate tool using the code snippet
9622 for ac_prog in tar
9623 do
9624 # Extract the first word of "$ac_prog", so it can be a program name with args.
9625 set dummy $ac_prog; ac_word=$2
9626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9627 $as_echo_n "checking for $ac_word... " >&6; }
9628 if ${ac_cv_path_TAR+:} false; then :
9629 $as_echo_n "(cached) " >&6
9630 else
9631 case $TAR in
9632 [\\/]* | ?:[\\/]*)
9633 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9634 ;;
9635 *)
9636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9637 for as_dir in $PATH
9638 do
9639 IFS=$as_save_IFS
9640 test -z "$as_dir" && as_dir=.
9641 for ac_exec_ext in '' $ac_executable_extensions; do
9642 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9643 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9644 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9645 break 2
9646 fi
9647 done
9648 done
9649 IFS=$as_save_IFS
9650
9651 ;;
9652 esac
9653 fi
9654 TAR=$ac_cv_path_TAR
9655 if test -n "$TAR"; then
9656 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9657 $as_echo "$TAR" >&6; }
9658 else
9659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9660 $as_echo "no" >&6; }
9661 fi
9662
9663
9664 test -n "$TAR" && break
9665 done
9666
9667 else
9668 # The variable is set, but is it from the command line or the environment?
9669
9670 # Try to remove the string !TAR! from our list.
9671 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9672 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9673 # If it failed, the variable was not from the command line. Ignore it,
9674 # but warn the user (except for BASH, which is always set by the calling BASH).
9675 if test "xTAR" != xBASH; then
9676 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9677 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9678 fi
9679 # Try to locate tool using the code snippet
9680 for ac_prog in tar
9681 do
9682 # Extract the first word of "$ac_prog", so it can be a program name with args.
9683 set dummy $ac_prog; ac_word=$2
9684 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9685 $as_echo_n "checking for $ac_word... " >&6; }
9686 if ${ac_cv_path_TAR+:} false; then :
9687 $as_echo_n "(cached) " >&6
9688 else
9689 case $TAR in
9690 [\\/]* | ?:[\\/]*)
9691 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9692 ;;
9693 *)
9694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $PATH
9696 do
9697 IFS=$as_save_IFS
9698 test -z "$as_dir" && as_dir=.
9699 for ac_exec_ext in '' $ac_executable_extensions; do
9700 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9702 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9703 break 2
9704 fi
9705 done
9706 done
9707 IFS=$as_save_IFS
9708
9709 ;;
9710 esac
9711 fi
9712 TAR=$ac_cv_path_TAR
9713 if test -n "$TAR"; then
9714 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9715 $as_echo "$TAR" >&6; }
9716 else
9717 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9718 $as_echo "no" >&6; }
9719 fi
9720
9721
9722 test -n "$TAR" && break
9723 done
9724
9725 else
9726 # If it succeeded, then it was overridden by the user. We will use it
9727 # for the tool.
9728
9729 # First remove it from the list of overridden variables, so we can test
9730 # for unknown variables in the end.
9731 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9732
9733 # Check if the provided tool contains a complete path.
9734 tool_specified="$TAR"
9735 tool_basename="${tool_specified##*/}"
9736 if test "x$tool_basename" = "x$tool_specified"; then
9737 # A command without a complete path is provided, search $PATH.
9738 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9739 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9740 # Extract the first word of "$tool_basename", so it can be a program name with args.
9741 set dummy $tool_basename; ac_word=$2
9742 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9743 $as_echo_n "checking for $ac_word... " >&6; }
9744 if ${ac_cv_path_TAR+:} false; then :
9745 $as_echo_n "(cached) " >&6
9746 else
9747 case $TAR in
9748 [\\/]* | ?:[\\/]*)
9749 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9750 ;;
9751 *)
9752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9753 for as_dir in $PATH
9754 do
9755 IFS=$as_save_IFS
9756 test -z "$as_dir" && as_dir=.
9757 for ac_exec_ext in '' $ac_executable_extensions; do
9758 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9759 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9760 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9761 break 2
9762 fi
9763 done
9764 done
9765 IFS=$as_save_IFS
9766
9767 ;;
9768 esac
9769 fi
9770 TAR=$ac_cv_path_TAR
9771 if test -n "$TAR"; then
9772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9773 $as_echo "$TAR" >&6; }
9774 else
9775 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9776 $as_echo "no" >&6; }
9777 fi
9778
9779
9780 if test "x$TAR" = x; then
9781 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9782 fi
9783 else
9784 # Otherwise we believe it is a complete path. Use it as it is.
9785 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9786 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9787 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9788 $as_echo_n "checking for TAR... " >&6; }
9789 if test ! -x "$tool_specified"; then
9790 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9791 $as_echo "not found" >&6; }
9792 as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9793 fi
9794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9795 $as_echo "$tool_specified" >&6; }
9796 fi
9797 fi
9798 fi
9799
9800
9801
9802 if test "x$TAR" = x; then
9803 as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9804 fi
9805
9806
9807
9808
9809
9810 # Publish this variable in the help.
9811
9812
9813 if test "x$TEE" = x; then
9814 # The variable is not set by user, try to locate tool using the code snippet
9815 for ac_prog in tee
9816 do
9817 # Extract the first word of "$ac_prog", so it can be a program name with args.
9818 set dummy $ac_prog; ac_word=$2
9819 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9820 $as_echo_n "checking for $ac_word... " >&6; }
9821 if ${ac_cv_path_TEE+:} false; then :
9822 $as_echo_n "(cached) " >&6
9823 else
9824 case $TEE in
9825 [\\/]* | ?:[\\/]*)
9826 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9827 ;;
9828 *)
9829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9830 for as_dir in $PATH
9831 do
9832 IFS=$as_save_IFS
9833 test -z "$as_dir" && as_dir=.
9834 for ac_exec_ext in '' $ac_executable_extensions; do
9835 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9836 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9837 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9838 break 2
9839 fi
9840 done
9841 done
9842 IFS=$as_save_IFS
9843
9844 ;;
9845 esac
9846 fi
9847 TEE=$ac_cv_path_TEE
9848 if test -n "$TEE"; then
9849 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9850 $as_echo "$TEE" >&6; }
9851 else
9852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9853 $as_echo "no" >&6; }
9854 fi
9855
9856
9857 test -n "$TEE" && break
9858 done
9859
9860 else
9861 # The variable is set, but is it from the command line or the environment?
9862
9863 # Try to remove the string !TEE! from our list.
9864 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9865 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9866 # If it failed, the variable was not from the command line. Ignore it,
9867 # but warn the user (except for BASH, which is always set by the calling BASH).
9868 if test "xTEE" != xBASH; then
9869 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9870 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9871 fi
9872 # Try to locate tool using the code snippet
9873 for ac_prog in tee
9874 do
9875 # Extract the first word of "$ac_prog", so it can be a program name with args.
9876 set dummy $ac_prog; ac_word=$2
9877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9878 $as_echo_n "checking for $ac_word... " >&6; }
9879 if ${ac_cv_path_TEE+:} false; then :
9880 $as_echo_n "(cached) " >&6
9881 else
9882 case $TEE in
9883 [\\/]* | ?:[\\/]*)
9884 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9885 ;;
9886 *)
9887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9888 for as_dir in $PATH
9889 do
9890 IFS=$as_save_IFS
9891 test -z "$as_dir" && as_dir=.
9892 for ac_exec_ext in '' $ac_executable_extensions; do
9893 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9894 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9895 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9896 break 2
9897 fi
9898 done
9899 done
9900 IFS=$as_save_IFS
9901
9902 ;;
9903 esac
9904 fi
9905 TEE=$ac_cv_path_TEE
9906 if test -n "$TEE"; then
9907 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9908 $as_echo "$TEE" >&6; }
9909 else
9910 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9911 $as_echo "no" >&6; }
9912 fi
9913
9914
9915 test -n "$TEE" && break
9916 done
9917
9918 else
9919 # If it succeeded, then it was overridden by the user. We will use it
9920 # for the tool.
9921
9922 # First remove it from the list of overridden variables, so we can test
9923 # for unknown variables in the end.
9924 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9925
9926 # Check if the provided tool contains a complete path.
9927 tool_specified="$TEE"
9928 tool_basename="${tool_specified##*/}"
9929 if test "x$tool_basename" = "x$tool_specified"; then
9930 # A command without a complete path is provided, search $PATH.
9931 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9932 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9933 # Extract the first word of "$tool_basename", so it can be a program name with args.
9934 set dummy $tool_basename; ac_word=$2
9935 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9936 $as_echo_n "checking for $ac_word... " >&6; }
9937 if ${ac_cv_path_TEE+:} false; then :
9938 $as_echo_n "(cached) " >&6
9939 else
9940 case $TEE in
9941 [\\/]* | ?:[\\/]*)
9942 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9943 ;;
9944 *)
9945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9946 for as_dir in $PATH
9947 do
9948 IFS=$as_save_IFS
9949 test -z "$as_dir" && as_dir=.
9950 for ac_exec_ext in '' $ac_executable_extensions; do
9951 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9952 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9953 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9954 break 2
9955 fi
9956 done
9957 done
9958 IFS=$as_save_IFS
9959
9960 ;;
9961 esac
9962 fi
9963 TEE=$ac_cv_path_TEE
9964 if test -n "$TEE"; then
9965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9966 $as_echo "$TEE" >&6; }
9967 else
9968 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9969 $as_echo "no" >&6; }
9970 fi
9971
9972
9973 if test "x$TEE" = x; then
9974 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9975 fi
9976 else
9977 # Otherwise we believe it is a complete path. Use it as it is.
9978 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9979 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9980 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9981 $as_echo_n "checking for TEE... " >&6; }
9982 if test ! -x "$tool_specified"; then
9983 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9984 $as_echo "not found" >&6; }
9985 as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
9986 fi
9987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9988 $as_echo "$tool_specified" >&6; }
9989 fi
9990 fi
9991 fi
9992
9993
9994
9995 if test "x$TEE" = x; then
9996 as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
9997 fi
9998
9999
10000
10001
10002
10003 # Publish this variable in the help.
10004
10005
10006 if test "x$TOUCH" = x; then
10007 # The variable is not set by user, try to locate tool using the code snippet
10008 for ac_prog in touch
10009 do
10010 # Extract the first word of "$ac_prog", so it can be a program name with args.
10011 set dummy $ac_prog; ac_word=$2
10012 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10013 $as_echo_n "checking for $ac_word... " >&6; }
10014 if ${ac_cv_path_TOUCH+:} false; then :
10015 $as_echo_n "(cached) " >&6
10016 else
10017 case $TOUCH in
10018 [\\/]* | ?:[\\/]*)
10019 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10020 ;;
10021 *)
10022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10023 for as_dir in $PATH
10024 do
10025 IFS=$as_save_IFS
10026 test -z "$as_dir" && as_dir=.
10027 for ac_exec_ext in '' $ac_executable_extensions; do
10028 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10029 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10030 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10031 break 2
10032 fi
10033 done
10034 done
10035 IFS=$as_save_IFS
10036
10037 ;;
10038 esac
10039 fi
10040 TOUCH=$ac_cv_path_TOUCH
10041 if test -n "$TOUCH"; then
10042 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10043 $as_echo "$TOUCH" >&6; }
10044 else
10045 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10046 $as_echo "no" >&6; }
10047 fi
10048
10049
10050 test -n "$TOUCH" && break
10051 done
10052
10053 else
10054 # The variable is set, but is it from the command line or the environment?
10055
10056 # Try to remove the string !TOUCH! from our list.
10057 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10058 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10059 # If it failed, the variable was not from the command line. Ignore it,
10060 # but warn the user (except for BASH, which is always set by the calling BASH).
10061 if test "xTOUCH" != xBASH; then
10062 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10063 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10064 fi
10065 # Try to locate tool using the code snippet
10066 for ac_prog in touch
10067 do
10068 # Extract the first word of "$ac_prog", so it can be a program name with args.
10069 set dummy $ac_prog; ac_word=$2
10070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10071 $as_echo_n "checking for $ac_word... " >&6; }
10072 if ${ac_cv_path_TOUCH+:} false; then :
10073 $as_echo_n "(cached) " >&6
10074 else
10075 case $TOUCH in
10076 [\\/]* | ?:[\\/]*)
10077 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10078 ;;
10079 *)
10080 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10081 for as_dir in $PATH
10082 do
10083 IFS=$as_save_IFS
10084 test -z "$as_dir" && as_dir=.
10085 for ac_exec_ext in '' $ac_executable_extensions; do
10086 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10087 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10088 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10089 break 2
10090 fi
10091 done
10092 done
10093 IFS=$as_save_IFS
10094
10095 ;;
10096 esac
10097 fi
10098 TOUCH=$ac_cv_path_TOUCH
10099 if test -n "$TOUCH"; then
10100 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10101 $as_echo "$TOUCH" >&6; }
10102 else
10103 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10104 $as_echo "no" >&6; }
10105 fi
10106
10107
10108 test -n "$TOUCH" && break
10109 done
10110
10111 else
10112 # If it succeeded, then it was overridden by the user. We will use it
10113 # for the tool.
10114
10115 # First remove it from the list of overridden variables, so we can test
10116 # for unknown variables in the end.
10117 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10118
10119 # Check if the provided tool contains a complete path.
10120 tool_specified="$TOUCH"
10121 tool_basename="${tool_specified##*/}"
10122 if test "x$tool_basename" = "x$tool_specified"; then
10123 # A command without a complete path is provided, search $PATH.
10124 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10125 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10126 # Extract the first word of "$tool_basename", so it can be a program name with args.
10127 set dummy $tool_basename; ac_word=$2
10128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10129 $as_echo_n "checking for $ac_word... " >&6; }
10130 if ${ac_cv_path_TOUCH+:} false; then :
10131 $as_echo_n "(cached) " >&6
10132 else
10133 case $TOUCH in
10134 [\\/]* | ?:[\\/]*)
10135 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10136 ;;
10137 *)
10138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10139 for as_dir in $PATH
10140 do
10141 IFS=$as_save_IFS
10142 test -z "$as_dir" && as_dir=.
10143 for ac_exec_ext in '' $ac_executable_extensions; do
10144 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10145 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10146 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10147 break 2
10148 fi
10149 done
10150 done
10151 IFS=$as_save_IFS
10152
10153 ;;
10154 esac
10155 fi
10156 TOUCH=$ac_cv_path_TOUCH
10157 if test -n "$TOUCH"; then
10158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10159 $as_echo "$TOUCH" >&6; }
10160 else
10161 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10162 $as_echo "no" >&6; }
10163 fi
10164
10165
10166 if test "x$TOUCH" = x; then
10167 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10168 fi
10169 else
10170 # Otherwise we believe it is a complete path. Use it as it is.
10171 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10172 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10173 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10174 $as_echo_n "checking for TOUCH... " >&6; }
10175 if test ! -x "$tool_specified"; then
10176 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10177 $as_echo "not found" >&6; }
10178 as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10179 fi
10180 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10181 $as_echo "$tool_specified" >&6; }
10182 fi
10183 fi
10184 fi
10185
10186
10187
10188 if test "x$TOUCH" = x; then
10189 as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10190 fi
10191
10192
10193
10194
10195
10196 # Publish this variable in the help.
10197
10198
10199 if test "x$TR" = x; then
10200 # The variable is not set by user, try to locate tool using the code snippet
10201 for ac_prog in tr
10202 do
10203 # Extract the first word of "$ac_prog", so it can be a program name with args.
10204 set dummy $ac_prog; ac_word=$2
10205 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10206 $as_echo_n "checking for $ac_word... " >&6; }
10207 if ${ac_cv_path_TR+:} false; then :
10208 $as_echo_n "(cached) " >&6
10209 else
10210 case $TR in
10211 [\\/]* | ?:[\\/]*)
10212 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10213 ;;
10214 *)
10215 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10216 for as_dir in $PATH
10217 do
10218 IFS=$as_save_IFS
10219 test -z "$as_dir" && as_dir=.
10220 for ac_exec_ext in '' $ac_executable_extensions; do
10221 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10222 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10223 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10224 break 2
10225 fi
10226 done
10227 done
10228 IFS=$as_save_IFS
10229
10230 ;;
10231 esac
10232 fi
10233 TR=$ac_cv_path_TR
10234 if test -n "$TR"; then
10235 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10236 $as_echo "$TR" >&6; }
10237 else
10238 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10239 $as_echo "no" >&6; }
10240 fi
10241
10242
10243 test -n "$TR" && break
10244 done
10245
10246 else
10247 # The variable is set, but is it from the command line or the environment?
10248
10249 # Try to remove the string !TR! from our list.
10250 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10251 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10252 # If it failed, the variable was not from the command line. Ignore it,
10253 # but warn the user (except for BASH, which is always set by the calling BASH).
10254 if test "xTR" != xBASH; then
10255 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10256 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10257 fi
10258 # Try to locate tool using the code snippet
10259 for ac_prog in tr
10260 do
10261 # Extract the first word of "$ac_prog", so it can be a program name with args.
10262 set dummy $ac_prog; ac_word=$2
10263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10264 $as_echo_n "checking for $ac_word... " >&6; }
10265 if ${ac_cv_path_TR+:} false; then :
10266 $as_echo_n "(cached) " >&6
10267 else
10268 case $TR in
10269 [\\/]* | ?:[\\/]*)
10270 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10271 ;;
10272 *)
10273 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10274 for as_dir in $PATH
10275 do
10276 IFS=$as_save_IFS
10277 test -z "$as_dir" && as_dir=.
10278 for ac_exec_ext in '' $ac_executable_extensions; do
10279 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10280 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10281 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10282 break 2
10283 fi
10284 done
10285 done
10286 IFS=$as_save_IFS
10287
10288 ;;
10289 esac
10290 fi
10291 TR=$ac_cv_path_TR
10292 if test -n "$TR"; then
10293 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10294 $as_echo "$TR" >&6; }
10295 else
10296 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10297 $as_echo "no" >&6; }
10298 fi
10299
10300
10301 test -n "$TR" && break
10302 done
10303
10304 else
10305 # If it succeeded, then it was overridden by the user. We will use it
10306 # for the tool.
10307
10308 # First remove it from the list of overridden variables, so we can test
10309 # for unknown variables in the end.
10310 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10311
10312 # Check if the provided tool contains a complete path.
10313 tool_specified="$TR"
10314 tool_basename="${tool_specified##*/}"
10315 if test "x$tool_basename" = "x$tool_specified"; then
10316 # A command without a complete path is provided, search $PATH.
10317 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10318 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10319 # Extract the first word of "$tool_basename", so it can be a program name with args.
10320 set dummy $tool_basename; ac_word=$2
10321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10322 $as_echo_n "checking for $ac_word... " >&6; }
10323 if ${ac_cv_path_TR+:} false; then :
10324 $as_echo_n "(cached) " >&6
10325 else
10326 case $TR in
10327 [\\/]* | ?:[\\/]*)
10328 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10329 ;;
10330 *)
10331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10332 for as_dir in $PATH
10333 do
10334 IFS=$as_save_IFS
10335 test -z "$as_dir" && as_dir=.
10336 for ac_exec_ext in '' $ac_executable_extensions; do
10337 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10338 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10339 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10340 break 2
10341 fi
10342 done
10343 done
10344 IFS=$as_save_IFS
10345
10346 ;;
10347 esac
10348 fi
10349 TR=$ac_cv_path_TR
10350 if test -n "$TR"; then
10351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10352 $as_echo "$TR" >&6; }
10353 else
10354 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10355 $as_echo "no" >&6; }
10356 fi
10357
10358
10359 if test "x$TR" = x; then
10360 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10361 fi
10362 else
10363 # Otherwise we believe it is a complete path. Use it as it is.
10364 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10365 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10367 $as_echo_n "checking for TR... " >&6; }
10368 if test ! -x "$tool_specified"; then
10369 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10370 $as_echo "not found" >&6; }
10371 as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10372 fi
10373 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10374 $as_echo "$tool_specified" >&6; }
10375 fi
10376 fi
10377 fi
10378
10379
10380
10381 if test "x$TR" = x; then
10382 as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10383 fi
10384
10385
10386
10387
10388
10389 # Publish this variable in the help.
10390
10391
10392 if test "x$UNAME" = x; then
10393 # The variable is not set by user, try to locate tool using the code snippet
10394 for ac_prog in uname
10395 do
10396 # Extract the first word of "$ac_prog", so it can be a program name with args.
10397 set dummy $ac_prog; ac_word=$2
10398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10399 $as_echo_n "checking for $ac_word... " >&6; }
10400 if ${ac_cv_path_UNAME+:} false; then :
10401 $as_echo_n "(cached) " >&6
10402 else
10403 case $UNAME in
10404 [\\/]* | ?:[\\/]*)
10405 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10406 ;;
10407 *)
10408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10409 for as_dir in $PATH
10410 do
10411 IFS=$as_save_IFS
10412 test -z "$as_dir" && as_dir=.
10413 for ac_exec_ext in '' $ac_executable_extensions; do
10414 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10415 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10416 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10417 break 2
10418 fi
10419 done
10420 done
10421 IFS=$as_save_IFS
10422
10423 ;;
10424 esac
10425 fi
10426 UNAME=$ac_cv_path_UNAME
10427 if test -n "$UNAME"; then
10428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10429 $as_echo "$UNAME" >&6; }
10430 else
10431 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10432 $as_echo "no" >&6; }
10433 fi
10434
10435
10436 test -n "$UNAME" && break
10437 done
10438
10439 else
10440 # The variable is set, but is it from the command line or the environment?
10441
10442 # Try to remove the string !UNAME! from our list.
10443 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10444 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10445 # If it failed, the variable was not from the command line. Ignore it,
10446 # but warn the user (except for BASH, which is always set by the calling BASH).
10447 if test "xUNAME" != xBASH; then
10448 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10449 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10450 fi
10451 # Try to locate tool using the code snippet
10452 for ac_prog in uname
10453 do
10454 # Extract the first word of "$ac_prog", so it can be a program name with args.
10455 set dummy $ac_prog; ac_word=$2
10456 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10457 $as_echo_n "checking for $ac_word... " >&6; }
10458 if ${ac_cv_path_UNAME+:} false; then :
10459 $as_echo_n "(cached) " >&6
10460 else
10461 case $UNAME in
10462 [\\/]* | ?:[\\/]*)
10463 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10464 ;;
10465 *)
10466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10467 for as_dir in $PATH
10468 do
10469 IFS=$as_save_IFS
10470 test -z "$as_dir" && as_dir=.
10471 for ac_exec_ext in '' $ac_executable_extensions; do
10472 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10473 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10474 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10475 break 2
10476 fi
10477 done
10478 done
10479 IFS=$as_save_IFS
10480
10481 ;;
10482 esac
10483 fi
10484 UNAME=$ac_cv_path_UNAME
10485 if test -n "$UNAME"; then
10486 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10487 $as_echo "$UNAME" >&6; }
10488 else
10489 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10490 $as_echo "no" >&6; }
10491 fi
10492
10493
10494 test -n "$UNAME" && break
10495 done
10496
10497 else
10498 # If it succeeded, then it was overridden by the user. We will use it
10499 # for the tool.
10500
10501 # First remove it from the list of overridden variables, so we can test
10502 # for unknown variables in the end.
10503 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10504
10505 # Check if the provided tool contains a complete path.
10506 tool_specified="$UNAME"
10507 tool_basename="${tool_specified##*/}"
10508 if test "x$tool_basename" = "x$tool_specified"; then
10509 # A command without a complete path is provided, search $PATH.
10510 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10511 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10512 # Extract the first word of "$tool_basename", so it can be a program name with args.
10513 set dummy $tool_basename; ac_word=$2
10514 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10515 $as_echo_n "checking for $ac_word... " >&6; }
10516 if ${ac_cv_path_UNAME+:} false; then :
10517 $as_echo_n "(cached) " >&6
10518 else
10519 case $UNAME in
10520 [\\/]* | ?:[\\/]*)
10521 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10522 ;;
10523 *)
10524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10525 for as_dir in $PATH
10526 do
10527 IFS=$as_save_IFS
10528 test -z "$as_dir" && as_dir=.
10529 for ac_exec_ext in '' $ac_executable_extensions; do
10530 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10531 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10532 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10533 break 2
10534 fi
10535 done
10536 done
10537 IFS=$as_save_IFS
10538
10539 ;;
10540 esac
10541 fi
10542 UNAME=$ac_cv_path_UNAME
10543 if test -n "$UNAME"; then
10544 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10545 $as_echo "$UNAME" >&6; }
10546 else
10547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10548 $as_echo "no" >&6; }
10549 fi
10550
10551
10552 if test "x$UNAME" = x; then
10553 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10554 fi
10555 else
10556 # Otherwise we believe it is a complete path. Use it as it is.
10557 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10558 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10559 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10560 $as_echo_n "checking for UNAME... " >&6; }
10561 if test ! -x "$tool_specified"; then
10562 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10563 $as_echo "not found" >&6; }
10564 as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10565 fi
10566 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10567 $as_echo "$tool_specified" >&6; }
10568 fi
10569 fi
10570 fi
10571
10572
10573
10574 if test "x$UNAME" = x; then
10575 as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10576 fi
10577
10578
10579
10580
10581
10582 # Publish this variable in the help.
10583
10584
10585 if test "x$UNIQ" = x; then
10586 # The variable is not set by user, try to locate tool using the code snippet
10587 for ac_prog in uniq
10588 do
10589 # Extract the first word of "$ac_prog", so it can be a program name with args.
10590 set dummy $ac_prog; ac_word=$2
10591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10592 $as_echo_n "checking for $ac_word... " >&6; }
10593 if ${ac_cv_path_UNIQ+:} false; then :
10594 $as_echo_n "(cached) " >&6
10595 else
10596 case $UNIQ in
10597 [\\/]* | ?:[\\/]*)
10598 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10599 ;;
10600 *)
10601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10602 for as_dir in $PATH
10603 do
10604 IFS=$as_save_IFS
10605 test -z "$as_dir" && as_dir=.
10606 for ac_exec_ext in '' $ac_executable_extensions; do
10607 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10608 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10609 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10610 break 2
10611 fi
10612 done
10613 done
10614 IFS=$as_save_IFS
10615
10616 ;;
10617 esac
10618 fi
10619 UNIQ=$ac_cv_path_UNIQ
10620 if test -n "$UNIQ"; then
10621 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10622 $as_echo "$UNIQ" >&6; }
10623 else
10624 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10625 $as_echo "no" >&6; }
10626 fi
10627
10628
10629 test -n "$UNIQ" && break
10630 done
10631
10632 else
10633 # The variable is set, but is it from the command line or the environment?
10634
10635 # Try to remove the string !UNIQ! from our list.
10636 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10637 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10638 # If it failed, the variable was not from the command line. Ignore it,
10639 # but warn the user (except for BASH, which is always set by the calling BASH).
10640 if test "xUNIQ" != xBASH; then
10641 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10642 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10643 fi
10644 # Try to locate tool using the code snippet
10645 for ac_prog in uniq
10646 do
10647 # Extract the first word of "$ac_prog", so it can be a program name with args.
10648 set dummy $ac_prog; ac_word=$2
10649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10650 $as_echo_n "checking for $ac_word... " >&6; }
10651 if ${ac_cv_path_UNIQ+:} false; then :
10652 $as_echo_n "(cached) " >&6
10653 else
10654 case $UNIQ in
10655 [\\/]* | ?:[\\/]*)
10656 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10657 ;;
10658 *)
10659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10660 for as_dir in $PATH
10661 do
10662 IFS=$as_save_IFS
10663 test -z "$as_dir" && as_dir=.
10664 for ac_exec_ext in '' $ac_executable_extensions; do
10665 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10666 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10667 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10668 break 2
10669 fi
10670 done
10671 done
10672 IFS=$as_save_IFS
10673
10674 ;;
10675 esac
10676 fi
10677 UNIQ=$ac_cv_path_UNIQ
10678 if test -n "$UNIQ"; then
10679 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10680 $as_echo "$UNIQ" >&6; }
10681 else
10682 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10683 $as_echo "no" >&6; }
10684 fi
10685
10686
10687 test -n "$UNIQ" && break
10688 done
10689
10690 else
10691 # If it succeeded, then it was overridden by the user. We will use it
10692 # for the tool.
10693
10694 # First remove it from the list of overridden variables, so we can test
10695 # for unknown variables in the end.
10696 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10697
10698 # Check if the provided tool contains a complete path.
10699 tool_specified="$UNIQ"
10700 tool_basename="${tool_specified##*/}"
10701 if test "x$tool_basename" = "x$tool_specified"; then
10702 # A command without a complete path is provided, search $PATH.
10703 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10704 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10705 # Extract the first word of "$tool_basename", so it can be a program name with args.
10706 set dummy $tool_basename; ac_word=$2
10707 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10708 $as_echo_n "checking for $ac_word... " >&6; }
10709 if ${ac_cv_path_UNIQ+:} false; then :
10710 $as_echo_n "(cached) " >&6
10711 else
10712 case $UNIQ in
10713 [\\/]* | ?:[\\/]*)
10714 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10715 ;;
10716 *)
10717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10718 for as_dir in $PATH
10719 do
10720 IFS=$as_save_IFS
10721 test -z "$as_dir" && as_dir=.
10722 for ac_exec_ext in '' $ac_executable_extensions; do
10723 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10724 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10725 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10726 break 2
10727 fi
10728 done
10729 done
10730 IFS=$as_save_IFS
10731
10732 ;;
10733 esac
10734 fi
10735 UNIQ=$ac_cv_path_UNIQ
10736 if test -n "$UNIQ"; then
10737 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10738 $as_echo "$UNIQ" >&6; }
10739 else
10740 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10741 $as_echo "no" >&6; }
10742 fi
10743
10744
10745 if test "x$UNIQ" = x; then
10746 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10747 fi
10748 else
10749 # Otherwise we believe it is a complete path. Use it as it is.
10750 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10751 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10752 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10753 $as_echo_n "checking for UNIQ... " >&6; }
10754 if test ! -x "$tool_specified"; then
10755 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10756 $as_echo "not found" >&6; }
10757 as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10758 fi
10759 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10760 $as_echo "$tool_specified" >&6; }
10761 fi
10762 fi
10763 fi
10764
10765
10766
10767 if test "x$UNIQ" = x; then
10768 as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10769 fi
10770
10771
10772
10773
10774
10775 # Publish this variable in the help.
10776
10777
10778 if test "x$WC" = x; then
10779 # The variable is not set by user, try to locate tool using the code snippet
10780 for ac_prog in wc
10781 do
10782 # Extract the first word of "$ac_prog", so it can be a program name with args.
10783 set dummy $ac_prog; ac_word=$2
10784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10785 $as_echo_n "checking for $ac_word... " >&6; }
10786 if ${ac_cv_path_WC+:} false; then :
10787 $as_echo_n "(cached) " >&6
10788 else
10789 case $WC in
10790 [\\/]* | ?:[\\/]*)
10791 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10792 ;;
10793 *)
10794 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10795 for as_dir in $PATH
10796 do
10797 IFS=$as_save_IFS
10798 test -z "$as_dir" && as_dir=.
10799 for ac_exec_ext in '' $ac_executable_extensions; do
10800 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10801 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10802 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10803 break 2
10804 fi
10805 done
10806 done
10807 IFS=$as_save_IFS
10808
10809 ;;
10810 esac
10811 fi
10812 WC=$ac_cv_path_WC
10813 if test -n "$WC"; then
10814 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10815 $as_echo "$WC" >&6; }
10816 else
10817 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10818 $as_echo "no" >&6; }
10819 fi
10820
10821
10822 test -n "$WC" && break
10823 done
10824
10825 else
10826 # The variable is set, but is it from the command line or the environment?
10827
10828 # Try to remove the string !WC! from our list.
10829 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10830 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10831 # If it failed, the variable was not from the command line. Ignore it,
10832 # but warn the user (except for BASH, which is always set by the calling BASH).
10833 if test "xWC" != xBASH; then
10834 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10835 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10836 fi
10837 # Try to locate tool using the code snippet
10838 for ac_prog in wc
10839 do
10840 # Extract the first word of "$ac_prog", so it can be a program name with args.
10841 set dummy $ac_prog; ac_word=$2
10842 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10843 $as_echo_n "checking for $ac_word... " >&6; }
10844 if ${ac_cv_path_WC+:} false; then :
10845 $as_echo_n "(cached) " >&6
10846 else
10847 case $WC in
10848 [\\/]* | ?:[\\/]*)
10849 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10850 ;;
10851 *)
10852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10853 for as_dir in $PATH
10854 do
10855 IFS=$as_save_IFS
10856 test -z "$as_dir" && as_dir=.
10857 for ac_exec_ext in '' $ac_executable_extensions; do
10858 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10859 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10860 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10861 break 2
10862 fi
10863 done
10864 done
10865 IFS=$as_save_IFS
10866
10867 ;;
10868 esac
10869 fi
10870 WC=$ac_cv_path_WC
10871 if test -n "$WC"; then
10872 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10873 $as_echo "$WC" >&6; }
10874 else
10875 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10876 $as_echo "no" >&6; }
10877 fi
10878
10879
10880 test -n "$WC" && break
10881 done
10882
10883 else
10884 # If it succeeded, then it was overridden by the user. We will use it
10885 # for the tool.
10886
10887 # First remove it from the list of overridden variables, so we can test
10888 # for unknown variables in the end.
10889 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10890
10891 # Check if the provided tool contains a complete path.
10892 tool_specified="$WC"
10893 tool_basename="${tool_specified##*/}"
10894 if test "x$tool_basename" = "x$tool_specified"; then
10895 # A command without a complete path is provided, search $PATH.
10896 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10897 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10898 # Extract the first word of "$tool_basename", so it can be a program name with args.
10899 set dummy $tool_basename; ac_word=$2
10900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10901 $as_echo_n "checking for $ac_word... " >&6; }
10902 if ${ac_cv_path_WC+:} false; then :
10903 $as_echo_n "(cached) " >&6
10904 else
10905 case $WC in
10906 [\\/]* | ?:[\\/]*)
10907 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10908 ;;
10909 *)
10910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10911 for as_dir in $PATH
10912 do
10913 IFS=$as_save_IFS
10914 test -z "$as_dir" && as_dir=.
10915 for ac_exec_ext in '' $ac_executable_extensions; do
10916 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10917 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10918 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10919 break 2
10920 fi
10921 done
10922 done
10923 IFS=$as_save_IFS
10924
10925 ;;
10926 esac
10927 fi
10928 WC=$ac_cv_path_WC
10929 if test -n "$WC"; then
10930 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10931 $as_echo "$WC" >&6; }
10932 else
10933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10934 $as_echo "no" >&6; }
10935 fi
10936
10937
10938 if test "x$WC" = x; then
10939 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10940 fi
10941 else
10942 # Otherwise we believe it is a complete path. Use it as it is.
10943 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10944 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10945 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10946 $as_echo_n "checking for WC... " >&6; }
10947 if test ! -x "$tool_specified"; then
10948 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10949 $as_echo "not found" >&6; }
10950 as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10951 fi
10952 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10953 $as_echo "$tool_specified" >&6; }
10954 fi
10955 fi
10956 fi
10957
10958
10959
10960 if test "x$WC" = x; then
10961 as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10962 fi
10963
10964
10965
10966
10967
10968 # Publish this variable in the help.
10969
10970
10971 if test "x$WHICH" = x; then
10972 # The variable is not set by user, try to locate tool using the code snippet
10973 for ac_prog in which
10974 do
10975 # Extract the first word of "$ac_prog", so it can be a program name with args.
10976 set dummy $ac_prog; ac_word=$2
10977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10978 $as_echo_n "checking for $ac_word... " >&6; }
10979 if ${ac_cv_path_WHICH+:} false; then :
10980 $as_echo_n "(cached) " >&6
10981 else
10982 case $WHICH in
10983 [\\/]* | ?:[\\/]*)
10984 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10985 ;;
10986 *)
10987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10988 for as_dir in $PATH
10989 do
10990 IFS=$as_save_IFS
10991 test -z "$as_dir" && as_dir=.
10992 for ac_exec_ext in '' $ac_executable_extensions; do
10993 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10994 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10995 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10996 break 2
10997 fi
10998 done
10999 done
11000 IFS=$as_save_IFS
11001
11002 ;;
11003 esac
11004 fi
11005 WHICH=$ac_cv_path_WHICH
11006 if test -n "$WHICH"; then
11007 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11008 $as_echo "$WHICH" >&6; }
11009 else
11010 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11011 $as_echo "no" >&6; }
11012 fi
11013
11014
11015 test -n "$WHICH" && break
11016 done
11017
11018 else
11019 # The variable is set, but is it from the command line or the environment?
11020
11021 # Try to remove the string !WHICH! from our list.
11022 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11023 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11024 # If it failed, the variable was not from the command line. Ignore it,
11025 # but warn the user (except for BASH, which is always set by the calling BASH).
11026 if test "xWHICH" != xBASH; then
11027 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11028 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11029 fi
11030 # Try to locate tool using the code snippet
11031 for ac_prog in which
11032 do
11033 # Extract the first word of "$ac_prog", so it can be a program name with args.
11034 set dummy $ac_prog; ac_word=$2
11035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11036 $as_echo_n "checking for $ac_word... " >&6; }
11037 if ${ac_cv_path_WHICH+:} false; then :
11038 $as_echo_n "(cached) " >&6
11039 else
11040 case $WHICH in
11041 [\\/]* | ?:[\\/]*)
11042 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11043 ;;
11044 *)
11045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11046 for as_dir in $PATH
11047 do
11048 IFS=$as_save_IFS
11049 test -z "$as_dir" && as_dir=.
11050 for ac_exec_ext in '' $ac_executable_extensions; do
11051 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11052 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11053 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11054 break 2
11055 fi
11056 done
11057 done
11058 IFS=$as_save_IFS
11059
11060 ;;
11061 esac
11062 fi
11063 WHICH=$ac_cv_path_WHICH
11064 if test -n "$WHICH"; then
11065 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11066 $as_echo "$WHICH" >&6; }
11067 else
11068 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11069 $as_echo "no" >&6; }
11070 fi
11071
11072
11073 test -n "$WHICH" && break
11074 done
11075
11076 else
11077 # If it succeeded, then it was overridden by the user. We will use it
11078 # for the tool.
11079
11080 # First remove it from the list of overridden variables, so we can test
11081 # for unknown variables in the end.
11082 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11083
11084 # Check if the provided tool contains a complete path.
11085 tool_specified="$WHICH"
11086 tool_basename="${tool_specified##*/}"
11087 if test "x$tool_basename" = "x$tool_specified"; then
11088 # A command without a complete path is provided, search $PATH.
11089 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11090 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11091 # Extract the first word of "$tool_basename", so it can be a program name with args.
11092 set dummy $tool_basename; ac_word=$2
11093 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11094 $as_echo_n "checking for $ac_word... " >&6; }
11095 if ${ac_cv_path_WHICH+:} false; then :
11096 $as_echo_n "(cached) " >&6
11097 else
11098 case $WHICH in
11099 [\\/]* | ?:[\\/]*)
11100 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11101 ;;
11102 *)
11103 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11104 for as_dir in $PATH
11105 do
11106 IFS=$as_save_IFS
11107 test -z "$as_dir" && as_dir=.
11108 for ac_exec_ext in '' $ac_executable_extensions; do
11109 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11110 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11111 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11112 break 2
11113 fi
11114 done
11115 done
11116 IFS=$as_save_IFS
11117
11118 ;;
11119 esac
11120 fi
11121 WHICH=$ac_cv_path_WHICH
11122 if test -n "$WHICH"; then
11123 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11124 $as_echo "$WHICH" >&6; }
11125 else
11126 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11127 $as_echo "no" >&6; }
11128 fi
11129
11130
11131 if test "x$WHICH" = x; then
11132 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11133 fi
11134 else
11135 # Otherwise we believe it is a complete path. Use it as it is.
11136 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11137 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11138 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11139 $as_echo_n "checking for WHICH... " >&6; }
11140 if test ! -x "$tool_specified"; then
11141 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11142 $as_echo "not found" >&6; }
11143 as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11144 fi
11145 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11146 $as_echo "$tool_specified" >&6; }
11147 fi
11148 fi
11149 fi
11150
11151
11152
11153 if test "x$WHICH" = x; then
11154 as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11155 fi
11156
11157
11158
11159
11160
11161 # Publish this variable in the help.
11162
11163
11164 if test "x$XARGS" = x; then
11165 # The variable is not set by user, try to locate tool using the code snippet
11166 for ac_prog in xargs
11167 do
11168 # Extract the first word of "$ac_prog", so it can be a program name with args.
11169 set dummy $ac_prog; ac_word=$2
11170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11171 $as_echo_n "checking for $ac_word... " >&6; }
11172 if ${ac_cv_path_XARGS+:} false; then :
11173 $as_echo_n "(cached) " >&6
11174 else
11175 case $XARGS in
11176 [\\/]* | ?:[\\/]*)
11177 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11178 ;;
11179 *)
11180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11181 for as_dir in $PATH
11182 do
11183 IFS=$as_save_IFS
11184 test -z "$as_dir" && as_dir=.
11185 for ac_exec_ext in '' $ac_executable_extensions; do
11186 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11187 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11188 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11189 break 2
11190 fi
11191 done
11192 done
11193 IFS=$as_save_IFS
11194
11195 ;;
11196 esac
11197 fi
11198 XARGS=$ac_cv_path_XARGS
11199 if test -n "$XARGS"; then
11200 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11201 $as_echo "$XARGS" >&6; }
11202 else
11203 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11204 $as_echo "no" >&6; }
11205 fi
11206
11207
11208 test -n "$XARGS" && break
11209 done
11210
11211 else
11212 # The variable is set, but is it from the command line or the environment?
11213
11214 # Try to remove the string !XARGS! from our list.
11215 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11216 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11217 # If it failed, the variable was not from the command line. Ignore it,
11218 # but warn the user (except for BASH, which is always set by the calling BASH).
11219 if test "xXARGS" != xBASH; then
11220 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11221 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11222 fi
11223 # Try to locate tool using the code snippet
11224 for ac_prog in xargs
11225 do
11226 # Extract the first word of "$ac_prog", so it can be a program name with args.
11227 set dummy $ac_prog; ac_word=$2
11228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11229 $as_echo_n "checking for $ac_word... " >&6; }
11230 if ${ac_cv_path_XARGS+:} false; then :
11231 $as_echo_n "(cached) " >&6
11232 else
11233 case $XARGS in
11234 [\\/]* | ?:[\\/]*)
11235 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11236 ;;
11237 *)
11238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11239 for as_dir in $PATH
11240 do
11241 IFS=$as_save_IFS
11242 test -z "$as_dir" && as_dir=.
11243 for ac_exec_ext in '' $ac_executable_extensions; do
11244 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11245 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11246 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11247 break 2
11248 fi
11249 done
11250 done
11251 IFS=$as_save_IFS
11252
11253 ;;
11254 esac
11255 fi
11256 XARGS=$ac_cv_path_XARGS
11257 if test -n "$XARGS"; then
11258 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11259 $as_echo "$XARGS" >&6; }
11260 else
11261 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11262 $as_echo "no" >&6; }
11263 fi
11264
11265
11266 test -n "$XARGS" && break
11267 done
11268
11269 else
11270 # If it succeeded, then it was overridden by the user. We will use it
11271 # for the tool.
11272
11273 # First remove it from the list of overridden variables, so we can test
11274 # for unknown variables in the end.
11275 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11276
11277 # Check if the provided tool contains a complete path.
11278 tool_specified="$XARGS"
11279 tool_basename="${tool_specified##*/}"
11280 if test "x$tool_basename" = "x$tool_specified"; then
11281 # A command without a complete path is provided, search $PATH.
11282 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11283 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11284 # Extract the first word of "$tool_basename", so it can be a program name with args.
11285 set dummy $tool_basename; ac_word=$2
11286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11287 $as_echo_n "checking for $ac_word... " >&6; }
11288 if ${ac_cv_path_XARGS+:} false; then :
11289 $as_echo_n "(cached) " >&6
11290 else
11291 case $XARGS in
11292 [\\/]* | ?:[\\/]*)
11293 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11294 ;;
11295 *)
11296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11297 for as_dir in $PATH
11298 do
11299 IFS=$as_save_IFS
11300 test -z "$as_dir" && as_dir=.
11301 for ac_exec_ext in '' $ac_executable_extensions; do
11302 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11303 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11304 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11305 break 2
11306 fi
11307 done
11308 done
11309 IFS=$as_save_IFS
11310
11311 ;;
11312 esac
11313 fi
11314 XARGS=$ac_cv_path_XARGS
11315 if test -n "$XARGS"; then
11316 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11317 $as_echo "$XARGS" >&6; }
11318 else
11319 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11320 $as_echo "no" >&6; }
11321 fi
11322
11323
11324 if test "x$XARGS" = x; then
11325 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11326 fi
11327 else
11328 # Otherwise we believe it is a complete path. Use it as it is.
11329 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11330 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11331 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11332 $as_echo_n "checking for XARGS... " >&6; }
11333 if test ! -x "$tool_specified"; then
11334 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11335 $as_echo "not found" >&6; }
11336 as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11337 fi
11338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11339 $as_echo "$tool_specified" >&6; }
11340 fi
11341 fi
11342 fi
11343
11344
11345
11346 if test "x$XARGS" = x; then
11347 as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11348 fi
11349
11350
11351
11352 # Then required tools that require some special treatment.
11353
11354
11355 # Publish this variable in the help.
11356
11357
11358 if test "x$AWK" = x; then
11359 # The variable is not set by user, try to locate tool using the code snippet
11360 for ac_prog in gawk mawk nawk awk
11361 do
11362 # Extract the first word of "$ac_prog", so it can be a program name with args.
11363 set dummy $ac_prog; ac_word=$2
11364 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11365 $as_echo_n "checking for $ac_word... " >&6; }
11366 if ${ac_cv_prog_AWK+:} false; then :
11367 $as_echo_n "(cached) " >&6
11368 else
11369 if test -n "$AWK"; then
11370 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11371 else
11372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11373 for as_dir in $PATH
11374 do
11375 IFS=$as_save_IFS
11376 test -z "$as_dir" && as_dir=.
11377 for ac_exec_ext in '' $ac_executable_extensions; do
11378 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11379 ac_cv_prog_AWK="$ac_prog"
11380 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11381 break 2
11382 fi
11383 done
11384 done
11385 IFS=$as_save_IFS
11386
11387 fi
11388 fi
11389 AWK=$ac_cv_prog_AWK
11390 if test -n "$AWK"; then
11391 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11392 $as_echo "$AWK" >&6; }
11393 else
11394 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11395 $as_echo "no" >&6; }
11396 fi
11397
11398
11399 test -n "$AWK" && break
11400 done
11401
11402 else
11403 # The variable is set, but is it from the command line or the environment?
11404
11405 # Try to remove the string !AWK! from our list.
11406 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11407 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11408 # If it failed, the variable was not from the command line. Ignore it,
11409 # but warn the user (except for BASH, which is always set by the calling BASH).
11410 if test "xAWK" != xBASH; then
11411 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11412 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11413 fi
11414 # Try to locate tool using the code snippet
11415 for ac_prog in gawk mawk nawk awk
11416 do
11417 # Extract the first word of "$ac_prog", so it can be a program name with args.
11418 set dummy $ac_prog; ac_word=$2
11419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11420 $as_echo_n "checking for $ac_word... " >&6; }
11421 if ${ac_cv_prog_AWK+:} false; then :
11422 $as_echo_n "(cached) " >&6
11423 else
11424 if test -n "$AWK"; then
11425 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11426 else
11427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11428 for as_dir in $PATH
11429 do
11430 IFS=$as_save_IFS
11431 test -z "$as_dir" && as_dir=.
11432 for ac_exec_ext in '' $ac_executable_extensions; do
11433 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11434 ac_cv_prog_AWK="$ac_prog"
11435 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11436 break 2
11437 fi
11438 done
11439 done
11440 IFS=$as_save_IFS
11441
11442 fi
11443 fi
11444 AWK=$ac_cv_prog_AWK
11445 if test -n "$AWK"; then
11446 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11447 $as_echo "$AWK" >&6; }
11448 else
11449 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11450 $as_echo "no" >&6; }
11451 fi
11452
11453
11454 test -n "$AWK" && break
11455 done
11456
11457 else
11458 # If it succeeded, then it was overridden by the user. We will use it
11459 # for the tool.
11460
11461 # First remove it from the list of overridden variables, so we can test
11462 # for unknown variables in the end.
11463 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11464
11465 # Check if the provided tool contains a complete path.
11466 tool_specified="$AWK"
11467 tool_basename="${tool_specified##*/}"
11468 if test "x$tool_basename" = "x$tool_specified"; then
11469 # A command without a complete path is provided, search $PATH.
11470 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11471 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11472 # Extract the first word of "$tool_basename", so it can be a program name with args.
11473 set dummy $tool_basename; ac_word=$2
11474 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11475 $as_echo_n "checking for $ac_word... " >&6; }
11476 if ${ac_cv_path_AWK+:} false; then :
11477 $as_echo_n "(cached) " >&6
11478 else
11479 case $AWK in
11480 [\\/]* | ?:[\\/]*)
11481 ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11482 ;;
11483 *)
11484 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11485 for as_dir in $PATH
11486 do
11487 IFS=$as_save_IFS
11488 test -z "$as_dir" && as_dir=.
11489 for ac_exec_ext in '' $ac_executable_extensions; do
11490 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11491 ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11492 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11493 break 2
11494 fi
11495 done
11496 done
11497 IFS=$as_save_IFS
11498
11499 ;;
11500 esac
11501 fi
11502 AWK=$ac_cv_path_AWK
11503 if test -n "$AWK"; then
11504 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11505 $as_echo "$AWK" >&6; }
11506 else
11507 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11508 $as_echo "no" >&6; }
11509 fi
11510
11511
11512 if test "x$AWK" = x; then
11513 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11514 fi
11515 else
11516 # Otherwise we believe it is a complete path. Use it as it is.
11517 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11518 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11519 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11520 $as_echo_n "checking for AWK... " >&6; }
11521 if test ! -x "$tool_specified"; then
11522 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11523 $as_echo "not found" >&6; }
11524 as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11525 fi
11526 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11527 $as_echo "$tool_specified" >&6; }
11528 fi
11529 fi
11530 fi
11531
11532
11533 if test "x$AWK" = x; then
11534 as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11535 fi
11536
11537
11538
11539
11540 # Publish this variable in the help.
11541
11542
11543 if test "x$GREP" = x; then
11544 # The variable is not set by user, try to locate tool using the code snippet
11545 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11546 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11547 if ${ac_cv_path_GREP+:} false; then :
11548 $as_echo_n "(cached) " >&6
11549 else
11550 if test -z "$GREP"; then
11551 ac_path_GREP_found=false
11552 # Loop through the user's path and test for each of PROGNAME-LIST
11553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11554 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11555 do
11556 IFS=$as_save_IFS
11557 test -z "$as_dir" && as_dir=.
11558 for ac_prog in grep ggrep; do
11559 for ac_exec_ext in '' $ac_executable_extensions; do
11560 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11561 as_fn_executable_p "$ac_path_GREP" || continue
11562 # Check for GNU ac_path_GREP and select it if it is found.
11563 # Check for GNU $ac_path_GREP
11564 case `"$ac_path_GREP" --version 2>&1` in
11565 *GNU*)
11566 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11567 *)
11568 ac_count=0
11569 $as_echo_n 0123456789 >"conftest.in"
11570 while :
11571 do
11572 cat "conftest.in" "conftest.in" >"conftest.tmp"
11573 mv "conftest.tmp" "conftest.in"
11574 cp "conftest.in" "conftest.nl"
11575 $as_echo 'GREP' >> "conftest.nl"
11576 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11577 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11578 as_fn_arith $ac_count + 1 && ac_count=$as_val
11579 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11580 # Best one so far, save it but keep looking for a better one
11581 ac_cv_path_GREP="$ac_path_GREP"
11582 ac_path_GREP_max=$ac_count
11583 fi
11584 # 10*(2^10) chars as input seems more than enough
11585 test $ac_count -gt 10 && break
11586 done
11587 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11588 esac
11589
11590 $ac_path_GREP_found && break 3
11591 done
11592 done
11593 done
11594 IFS=$as_save_IFS
11595 if test -z "$ac_cv_path_GREP"; then
11596 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11597 fi
11598 else
11599 ac_cv_path_GREP=$GREP
11600 fi
11601
11602 fi
11603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11604 $as_echo "$ac_cv_path_GREP" >&6; }
11605 GREP="$ac_cv_path_GREP"
11606
11607
11608 else
11609 # The variable is set, but is it from the command line or the environment?
11610
11611 # Try to remove the string !GREP! from our list.
11612 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11613 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11614 # If it failed, the variable was not from the command line. Ignore it,
11615 # but warn the user (except for BASH, which is always set by the calling BASH).
11616 if test "xGREP" != xBASH; then
11617 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11618 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11619 fi
11620 # Try to locate tool using the code snippet
11621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11622 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11623 if ${ac_cv_path_GREP+:} false; then :
11624 $as_echo_n "(cached) " >&6
11625 else
11626 if test -z "$GREP"; then
11627 ac_path_GREP_found=false
11628 # Loop through the user's path and test for each of PROGNAME-LIST
11629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11630 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11631 do
11632 IFS=$as_save_IFS
11633 test -z "$as_dir" && as_dir=.
11634 for ac_prog in grep ggrep; do
11635 for ac_exec_ext in '' $ac_executable_extensions; do
11636 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11637 as_fn_executable_p "$ac_path_GREP" || continue
11638 # Check for GNU ac_path_GREP and select it if it is found.
11639 # Check for GNU $ac_path_GREP
11640 case `"$ac_path_GREP" --version 2>&1` in
11641 *GNU*)
11642 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11643 *)
11644 ac_count=0
11645 $as_echo_n 0123456789 >"conftest.in"
11646 while :
11647 do
11648 cat "conftest.in" "conftest.in" >"conftest.tmp"
11649 mv "conftest.tmp" "conftest.in"
11650 cp "conftest.in" "conftest.nl"
11651 $as_echo 'GREP' >> "conftest.nl"
11652 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11653 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11654 as_fn_arith $ac_count + 1 && ac_count=$as_val
11655 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11656 # Best one so far, save it but keep looking for a better one
11657 ac_cv_path_GREP="$ac_path_GREP"
11658 ac_path_GREP_max=$ac_count
11659 fi
11660 # 10*(2^10) chars as input seems more than enough
11661 test $ac_count -gt 10 && break
11662 done
11663 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11664 esac
11665
11666 $ac_path_GREP_found && break 3
11667 done
11668 done
11669 done
11670 IFS=$as_save_IFS
11671 if test -z "$ac_cv_path_GREP"; then
11672 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11673 fi
11674 else
11675 ac_cv_path_GREP=$GREP
11676 fi
11677
11678 fi
11679 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11680 $as_echo "$ac_cv_path_GREP" >&6; }
11681 GREP="$ac_cv_path_GREP"
11682
11683
11684 else
11685 # If it succeeded, then it was overridden by the user. We will use it
11686 # for the tool.
11687
11688 # First remove it from the list of overridden variables, so we can test
11689 # for unknown variables in the end.
11690 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11691
11692 # Check if the provided tool contains a complete path.
11693 tool_specified="$GREP"
11694 tool_basename="${tool_specified##*/}"
11695 if test "x$tool_basename" = "x$tool_specified"; then
11696 # A command without a complete path is provided, search $PATH.
11697 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11698 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11699 # Extract the first word of "$tool_basename", so it can be a program name with args.
11700 set dummy $tool_basename; ac_word=$2
11701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11702 $as_echo_n "checking for $ac_word... " >&6; }
11703 if ${ac_cv_path_GREP+:} false; then :
11704 $as_echo_n "(cached) " >&6
11705 else
11706 case $GREP in
11707 [\\/]* | ?:[\\/]*)
11708 ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11709 ;;
11710 *)
11711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11712 for as_dir in $PATH
11713 do
11714 IFS=$as_save_IFS
11715 test -z "$as_dir" && as_dir=.
11716 for ac_exec_ext in '' $ac_executable_extensions; do
11717 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11718 ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11719 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11720 break 2
11721 fi
11722 done
11723 done
11724 IFS=$as_save_IFS
11725
11726 ;;
11727 esac
11728 fi
11729 GREP=$ac_cv_path_GREP
11730 if test -n "$GREP"; then
11731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11732 $as_echo "$GREP" >&6; }
11733 else
11734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11735 $as_echo "no" >&6; }
11736 fi
11737
11738
11739 if test "x$GREP" = x; then
11740 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11741 fi
11742 else
11743 # Otherwise we believe it is a complete path. Use it as it is.
11744 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11745 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11747 $as_echo_n "checking for GREP... " >&6; }
11748 if test ! -x "$tool_specified"; then
11749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11750 $as_echo "not found" >&6; }
11751 as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11752 fi
11753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11754 $as_echo "$tool_specified" >&6; }
11755 fi
11756 fi
11757 fi
11758
11759
11760 if test "x$GREP" = x; then
11761 as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11762 fi
11763
11764
11765
11766
11767 # Publish this variable in the help.
11768
11769
11770 if test "x$EGREP" = x; then
11771 # The variable is not set by user, try to locate tool using the code snippet
11772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11773 $as_echo_n "checking for egrep... " >&6; }
11774 if ${ac_cv_path_EGREP+:} false; then :
11775 $as_echo_n "(cached) " >&6
11776 else
11777 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11778 then ac_cv_path_EGREP="$GREP -E"
11779 else
11780 if test -z "$EGREP"; then
11781 ac_path_EGREP_found=false
11782 # Loop through the user's path and test for each of PROGNAME-LIST
11783 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11784 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11785 do
11786 IFS=$as_save_IFS
11787 test -z "$as_dir" && as_dir=.
11788 for ac_prog in egrep; do
11789 for ac_exec_ext in '' $ac_executable_extensions; do
11790 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11791 as_fn_executable_p "$ac_path_EGREP" || continue
11792 # Check for GNU ac_path_EGREP and select it if it is found.
11793 # Check for GNU $ac_path_EGREP
11794 case `"$ac_path_EGREP" --version 2>&1` in
11795 *GNU*)
11796 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11797 *)
11798 ac_count=0
11799 $as_echo_n 0123456789 >"conftest.in"
11800 while :
11801 do
11802 cat "conftest.in" "conftest.in" >"conftest.tmp"
11803 mv "conftest.tmp" "conftest.in"
11804 cp "conftest.in" "conftest.nl"
11805 $as_echo 'EGREP' >> "conftest.nl"
11806 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11807 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11808 as_fn_arith $ac_count + 1 && ac_count=$as_val
11809 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11810 # Best one so far, save it but keep looking for a better one
11811 ac_cv_path_EGREP="$ac_path_EGREP"
11812 ac_path_EGREP_max=$ac_count
11813 fi
11814 # 10*(2^10) chars as input seems more than enough
11815 test $ac_count -gt 10 && break
11816 done
11817 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11818 esac
11819
11820 $ac_path_EGREP_found && break 3
11821 done
11822 done
11823 done
11824 IFS=$as_save_IFS
11825 if test -z "$ac_cv_path_EGREP"; then
11826 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11827 fi
11828 else
11829 ac_cv_path_EGREP=$EGREP
11830 fi
11831
11832 fi
11833 fi
11834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11835 $as_echo "$ac_cv_path_EGREP" >&6; }
11836 EGREP="$ac_cv_path_EGREP"
11837
11838
11839 else
11840 # The variable is set, but is it from the command line or the environment?
11841
11842 # Try to remove the string !EGREP! from our list.
11843 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11844 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11845 # If it failed, the variable was not from the command line. Ignore it,
11846 # but warn the user (except for BASH, which is always set by the calling BASH).
11847 if test "xEGREP" != xBASH; then
11848 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11849 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11850 fi
11851 # Try to locate tool using the code snippet
11852 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11853 $as_echo_n "checking for egrep... " >&6; }
11854 if ${ac_cv_path_EGREP+:} false; then :
11855 $as_echo_n "(cached) " >&6
11856 else
11857 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11858 then ac_cv_path_EGREP="$GREP -E"
11859 else
11860 if test -z "$EGREP"; then
11861 ac_path_EGREP_found=false
11862 # Loop through the user's path and test for each of PROGNAME-LIST
11863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11864 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11865 do
11866 IFS=$as_save_IFS
11867 test -z "$as_dir" && as_dir=.
11868 for ac_prog in egrep; do
11869 for ac_exec_ext in '' $ac_executable_extensions; do
11870 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11871 as_fn_executable_p "$ac_path_EGREP" || continue
11872 # Check for GNU ac_path_EGREP and select it if it is found.
11873 # Check for GNU $ac_path_EGREP
11874 case `"$ac_path_EGREP" --version 2>&1` in
11875 *GNU*)
11876 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11877 *)
11878 ac_count=0
11879 $as_echo_n 0123456789 >"conftest.in"
11880 while :
11881 do
11882 cat "conftest.in" "conftest.in" >"conftest.tmp"
11883 mv "conftest.tmp" "conftest.in"
11884 cp "conftest.in" "conftest.nl"
11885 $as_echo 'EGREP' >> "conftest.nl"
11886 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11887 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11888 as_fn_arith $ac_count + 1 && ac_count=$as_val
11889 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11890 # Best one so far, save it but keep looking for a better one
11891 ac_cv_path_EGREP="$ac_path_EGREP"
11892 ac_path_EGREP_max=$ac_count
11893 fi
11894 # 10*(2^10) chars as input seems more than enough
11895 test $ac_count -gt 10 && break
11896 done
11897 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11898 esac
11899
11900 $ac_path_EGREP_found && break 3
11901 done
11902 done
11903 done
11904 IFS=$as_save_IFS
11905 if test -z "$ac_cv_path_EGREP"; then
11906 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11907 fi
11908 else
11909 ac_cv_path_EGREP=$EGREP
11910 fi
11911
11912 fi
11913 fi
11914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11915 $as_echo "$ac_cv_path_EGREP" >&6; }
11916 EGREP="$ac_cv_path_EGREP"
11917
11918
11919 else
11920 # If it succeeded, then it was overridden by the user. We will use it
11921 # for the tool.
11922
11923 # First remove it from the list of overridden variables, so we can test
11924 # for unknown variables in the end.
11925 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11926
11927 # Check if the provided tool contains a complete path.
11928 tool_specified="$EGREP"
11929 tool_basename="${tool_specified##*/}"
11930 if test "x$tool_basename" = "x$tool_specified"; then
11931 # A command without a complete path is provided, search $PATH.
11932 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11933 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11934 # Extract the first word of "$tool_basename", so it can be a program name with args.
11935 set dummy $tool_basename; ac_word=$2
11936 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11937 $as_echo_n "checking for $ac_word... " >&6; }
11938 if ${ac_cv_path_EGREP+:} false; then :
11939 $as_echo_n "(cached) " >&6
11940 else
11941 case $EGREP in
11942 [\\/]* | ?:[\\/]*)
11943 ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11944 ;;
11945 *)
11946 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11947 for as_dir in $PATH
11948 do
11949 IFS=$as_save_IFS
11950 test -z "$as_dir" && as_dir=.
11951 for ac_exec_ext in '' $ac_executable_extensions; do
11952 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11953 ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11954 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11955 break 2
11956 fi
11957 done
11958 done
11959 IFS=$as_save_IFS
11960
11961 ;;
11962 esac
11963 fi
11964 EGREP=$ac_cv_path_EGREP
11965 if test -n "$EGREP"; then
11966 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11967 $as_echo "$EGREP" >&6; }
11968 else
11969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11970 $as_echo "no" >&6; }
11971 fi
11972
11973
11974 if test "x$EGREP" = x; then
11975 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11976 fi
11977 else
11978 # Otherwise we believe it is a complete path. Use it as it is.
11979 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11980 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11981 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11982 $as_echo_n "checking for EGREP... " >&6; }
11983 if test ! -x "$tool_specified"; then
11984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11985 $as_echo "not found" >&6; }
11986 as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11987 fi
11988 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11989 $as_echo "$tool_specified" >&6; }
11990 fi
11991 fi
11992 fi
11993
11994
11995 if test "x$EGREP" = x; then
11996 as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
11997 fi
11998
11999
12000
12001
12002 # Publish this variable in the help.
12003
12004
12005 if test "x$FGREP" = x; then
12006 # The variable is not set by user, try to locate tool using the code snippet
12007 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12008 $as_echo_n "checking for fgrep... " >&6; }
12009 if ${ac_cv_path_FGREP+:} false; then :
12010 $as_echo_n "(cached) " >&6
12011 else
12012 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12013 then ac_cv_path_FGREP="$GREP -F"
12014 else
12015 if test -z "$FGREP"; then
12016 ac_path_FGREP_found=false
12017 # Loop through the user's path and test for each of PROGNAME-LIST
12018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12019 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12020 do
12021 IFS=$as_save_IFS
12022 test -z "$as_dir" && as_dir=.
12023 for ac_prog in fgrep; do
12024 for ac_exec_ext in '' $ac_executable_extensions; do
12025 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12026 as_fn_executable_p "$ac_path_FGREP" || continue
12027 # Check for GNU ac_path_FGREP and select it if it is found.
12028 # Check for GNU $ac_path_FGREP
12029 case `"$ac_path_FGREP" --version 2>&1` in
12030 *GNU*)
12031 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12032 *)
12033 ac_count=0
12034 $as_echo_n 0123456789 >"conftest.in"
12035 while :
12036 do
12037 cat "conftest.in" "conftest.in" >"conftest.tmp"
12038 mv "conftest.tmp" "conftest.in"
12039 cp "conftest.in" "conftest.nl"
12040 $as_echo 'FGREP' >> "conftest.nl"
12041 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12042 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12043 as_fn_arith $ac_count + 1 && ac_count=$as_val
12044 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12045 # Best one so far, save it but keep looking for a better one
12046 ac_cv_path_FGREP="$ac_path_FGREP"
12047 ac_path_FGREP_max=$ac_count
12048 fi
12049 # 10*(2^10) chars as input seems more than enough
12050 test $ac_count -gt 10 && break
12051 done
12052 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12053 esac
12054
12055 $ac_path_FGREP_found && break 3
12056 done
12057 done
12058 done
12059 IFS=$as_save_IFS
12060 if test -z "$ac_cv_path_FGREP"; then
12061 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12062 fi
12063 else
12064 ac_cv_path_FGREP=$FGREP
12065 fi
12066
12067 fi
12068 fi
12069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12070 $as_echo "$ac_cv_path_FGREP" >&6; }
12071 FGREP="$ac_cv_path_FGREP"
12072
12073
12074 else
12075 # The variable is set, but is it from the command line or the environment?
12076
12077 # Try to remove the string !FGREP! from our list.
12078 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12079 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12080 # If it failed, the variable was not from the command line. Ignore it,
12081 # but warn the user (except for BASH, which is always set by the calling BASH).
12082 if test "xFGREP" != xBASH; then
12083 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12084 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12085 fi
12086 # Try to locate tool using the code snippet
12087 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12088 $as_echo_n "checking for fgrep... " >&6; }
12089 if ${ac_cv_path_FGREP+:} false; then :
12090 $as_echo_n "(cached) " >&6
12091 else
12092 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12093 then ac_cv_path_FGREP="$GREP -F"
12094 else
12095 if test -z "$FGREP"; then
12096 ac_path_FGREP_found=false
12097 # Loop through the user's path and test for each of PROGNAME-LIST
12098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12099 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12100 do
12101 IFS=$as_save_IFS
12102 test -z "$as_dir" && as_dir=.
12103 for ac_prog in fgrep; do
12104 for ac_exec_ext in '' $ac_executable_extensions; do
12105 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12106 as_fn_executable_p "$ac_path_FGREP" || continue
12107 # Check for GNU ac_path_FGREP and select it if it is found.
12108 # Check for GNU $ac_path_FGREP
12109 case `"$ac_path_FGREP" --version 2>&1` in
12110 *GNU*)
12111 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12112 *)
12113 ac_count=0
12114 $as_echo_n 0123456789 >"conftest.in"
12115 while :
12116 do
12117 cat "conftest.in" "conftest.in" >"conftest.tmp"
12118 mv "conftest.tmp" "conftest.in"
12119 cp "conftest.in" "conftest.nl"
12120 $as_echo 'FGREP' >> "conftest.nl"
12121 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12122 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12123 as_fn_arith $ac_count + 1 && ac_count=$as_val
12124 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12125 # Best one so far, save it but keep looking for a better one
12126 ac_cv_path_FGREP="$ac_path_FGREP"
12127 ac_path_FGREP_max=$ac_count
12128 fi
12129 # 10*(2^10) chars as input seems more than enough
12130 test $ac_count -gt 10 && break
12131 done
12132 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12133 esac
12134
12135 $ac_path_FGREP_found && break 3
12136 done
12137 done
12138 done
12139 IFS=$as_save_IFS
12140 if test -z "$ac_cv_path_FGREP"; then
12141 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12142 fi
12143 else
12144 ac_cv_path_FGREP=$FGREP
12145 fi
12146
12147 fi
12148 fi
12149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12150 $as_echo "$ac_cv_path_FGREP" >&6; }
12151 FGREP="$ac_cv_path_FGREP"
12152
12153
12154 else
12155 # If it succeeded, then it was overridden by the user. We will use it
12156 # for the tool.
12157
12158 # First remove it from the list of overridden variables, so we can test
12159 # for unknown variables in the end.
12160 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12161
12162 # Check if the provided tool contains a complete path.
12163 tool_specified="$FGREP"
12164 tool_basename="${tool_specified##*/}"
12165 if test "x$tool_basename" = "x$tool_specified"; then
12166 # A command without a complete path is provided, search $PATH.
12167 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12168 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12169 # Extract the first word of "$tool_basename", so it can be a program name with args.
12170 set dummy $tool_basename; ac_word=$2
12171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12172 $as_echo_n "checking for $ac_word... " >&6; }
12173 if ${ac_cv_path_FGREP+:} false; then :
12174 $as_echo_n "(cached) " >&6
12175 else
12176 case $FGREP in
12177 [\\/]* | ?:[\\/]*)
12178 ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12179 ;;
12180 *)
12181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12182 for as_dir in $PATH
12183 do
12184 IFS=$as_save_IFS
12185 test -z "$as_dir" && as_dir=.
12186 for ac_exec_ext in '' $ac_executable_extensions; do
12187 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12188 ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12189 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12190 break 2
12191 fi
12192 done
12193 done
12194 IFS=$as_save_IFS
12195
12196 ;;
12197 esac
12198 fi
12199 FGREP=$ac_cv_path_FGREP
12200 if test -n "$FGREP"; then
12201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12202 $as_echo "$FGREP" >&6; }
12203 else
12204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12205 $as_echo "no" >&6; }
12206 fi
12207
12208
12209 if test "x$FGREP" = x; then
12210 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12211 fi
12212 else
12213 # Otherwise we believe it is a complete path. Use it as it is.
12214 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12215 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12216 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12217 $as_echo_n "checking for FGREP... " >&6; }
12218 if test ! -x "$tool_specified"; then
12219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12220 $as_echo "not found" >&6; }
12221 as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12222 fi
12223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12224 $as_echo "$tool_specified" >&6; }
12225 fi
12226 fi
12227 fi
12228
12229
12230 if test "x$FGREP" = x; then
12231 as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12232 fi
12233
12234
12235
12236
12237 # Publish this variable in the help.
12238
12239
12240 if test "x$SED" = x; then
12241 # The variable is not set by user, try to locate tool using the code snippet
12242 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12243 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12244 if ${ac_cv_path_SED+:} false; then :
12245 $as_echo_n "(cached) " >&6
12246 else
12247 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12248 for ac_i in 1 2 3 4 5 6 7; do
12249 ac_script="$ac_script$as_nl$ac_script"
12250 done
12251 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12252 { ac_script=; unset ac_script;}
12253 if test -z "$SED"; then
12254 ac_path_SED_found=false
12255 # Loop through the user's path and test for each of PROGNAME-LIST
12256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12257 for as_dir in $PATH
12258 do
12259 IFS=$as_save_IFS
12260 test -z "$as_dir" && as_dir=.
12261 for ac_prog in sed gsed; do
12262 for ac_exec_ext in '' $ac_executable_extensions; do
12263 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12264 as_fn_executable_p "$ac_path_SED" || continue
12265 # Check for GNU ac_path_SED and select it if it is found.
12266 # Check for GNU $ac_path_SED
12267 case `"$ac_path_SED" --version 2>&1` in
12268 *GNU*)
12269 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12270 *)
12271 ac_count=0
12272 $as_echo_n 0123456789 >"conftest.in"
12273 while :
12274 do
12275 cat "conftest.in" "conftest.in" >"conftest.tmp"
12276 mv "conftest.tmp" "conftest.in"
12277 cp "conftest.in" "conftest.nl"
12278 $as_echo '' >> "conftest.nl"
12279 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12280 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12281 as_fn_arith $ac_count + 1 && ac_count=$as_val
12282 if test $ac_count -gt ${ac_path_SED_max-0}; then
12283 # Best one so far, save it but keep looking for a better one
12284 ac_cv_path_SED="$ac_path_SED"
12285 ac_path_SED_max=$ac_count
12286 fi
12287 # 10*(2^10) chars as input seems more than enough
12288 test $ac_count -gt 10 && break
12289 done
12290 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12291 esac
12292
12293 $ac_path_SED_found && break 3
12294 done
12295 done
12296 done
12297 IFS=$as_save_IFS
12298 if test -z "$ac_cv_path_SED"; then
12299 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12300 fi
12301 else
12302 ac_cv_path_SED=$SED
12303 fi
12304
12305 fi
12306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12307 $as_echo "$ac_cv_path_SED" >&6; }
12308 SED="$ac_cv_path_SED"
12309 rm -f conftest.sed
12310
12311 else
12312 # The variable is set, but is it from the command line or the environment?
12313
12314 # Try to remove the string !SED! from our list.
12315 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12316 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12317 # If it failed, the variable was not from the command line. Ignore it,
12318 # but warn the user (except for BASH, which is always set by the calling BASH).
12319 if test "xSED" != xBASH; then
12320 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12321 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12322 fi
12323 # Try to locate tool using the code snippet
12324 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12325 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12326 if ${ac_cv_path_SED+:} false; then :
12327 $as_echo_n "(cached) " >&6
12328 else
12329 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12330 for ac_i in 1 2 3 4 5 6 7; do
12331 ac_script="$ac_script$as_nl$ac_script"
12332 done
12333 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12334 { ac_script=; unset ac_script;}
12335 if test -z "$SED"; then
12336 ac_path_SED_found=false
12337 # Loop through the user's path and test for each of PROGNAME-LIST
12338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12339 for as_dir in $PATH
12340 do
12341 IFS=$as_save_IFS
12342 test -z "$as_dir" && as_dir=.
12343 for ac_prog in sed gsed; do
12344 for ac_exec_ext in '' $ac_executable_extensions; do
12345 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12346 as_fn_executable_p "$ac_path_SED" || continue
12347 # Check for GNU ac_path_SED and select it if it is found.
12348 # Check for GNU $ac_path_SED
12349 case `"$ac_path_SED" --version 2>&1` in
12350 *GNU*)
12351 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12352 *)
12353 ac_count=0
12354 $as_echo_n 0123456789 >"conftest.in"
12355 while :
12356 do
12357 cat "conftest.in" "conftest.in" >"conftest.tmp"
12358 mv "conftest.tmp" "conftest.in"
12359 cp "conftest.in" "conftest.nl"
12360 $as_echo '' >> "conftest.nl"
12361 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12362 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12363 as_fn_arith $ac_count + 1 && ac_count=$as_val
12364 if test $ac_count -gt ${ac_path_SED_max-0}; then
12365 # Best one so far, save it but keep looking for a better one
12366 ac_cv_path_SED="$ac_path_SED"
12367 ac_path_SED_max=$ac_count
12368 fi
12369 # 10*(2^10) chars as input seems more than enough
12370 test $ac_count -gt 10 && break
12371 done
12372 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12373 esac
12374
12375 $ac_path_SED_found && break 3
12376 done
12377 done
12378 done
12379 IFS=$as_save_IFS
12380 if test -z "$ac_cv_path_SED"; then
12381 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12382 fi
12383 else
12384 ac_cv_path_SED=$SED
12385 fi
12386
12387 fi
12388 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12389 $as_echo "$ac_cv_path_SED" >&6; }
12390 SED="$ac_cv_path_SED"
12391 rm -f conftest.sed
12392
12393 else
12394 # If it succeeded, then it was overridden by the user. We will use it
12395 # for the tool.
12396
12397 # First remove it from the list of overridden variables, so we can test
12398 # for unknown variables in the end.
12399 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12400
12401 # Check if the provided tool contains a complete path.
12402 tool_specified="$SED"
12403 tool_basename="${tool_specified##*/}"
12404 if test "x$tool_basename" = "x$tool_specified"; then
12405 # A command without a complete path is provided, search $PATH.
12406 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12407 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12408 # Extract the first word of "$tool_basename", so it can be a program name with args.
12409 set dummy $tool_basename; ac_word=$2
12410 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12411 $as_echo_n "checking for $ac_word... " >&6; }
12412 if ${ac_cv_path_SED+:} false; then :
12413 $as_echo_n "(cached) " >&6
12414 else
12415 case $SED in
12416 [\\/]* | ?:[\\/]*)
12417 ac_cv_path_SED="$SED" # Let the user override the test with a path.
12418 ;;
12419 *)
12420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12421 for as_dir in $PATH
12422 do
12423 IFS=$as_save_IFS
12424 test -z "$as_dir" && as_dir=.
12425 for ac_exec_ext in '' $ac_executable_extensions; do
12426 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12427 ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12428 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12429 break 2
12430 fi
12431 done
12432 done
12433 IFS=$as_save_IFS
12434
12435 ;;
12436 esac
12437 fi
12438 SED=$ac_cv_path_SED
12439 if test -n "$SED"; then
12440 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12441 $as_echo "$SED" >&6; }
12442 else
12443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12444 $as_echo "no" >&6; }
12445 fi
12446
12447
12448 if test "x$SED" = x; then
12449 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12450 fi
12451 else
12452 # Otherwise we believe it is a complete path. Use it as it is.
12453 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12454 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12456 $as_echo_n "checking for SED... " >&6; }
12457 if test ! -x "$tool_specified"; then
12458 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12459 $as_echo "not found" >&6; }
12460 as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12461 fi
12462 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12463 $as_echo "$tool_specified" >&6; }
12464 fi
12465 fi
12466 fi
12467
12468
12469 if test "x$SED" = x; then
12470 as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12471 fi
12472
12473
12474
12475 # Always force rm.
12476 RM="$RM -f"
12477
12478 # pwd behaves differently on various platforms and some don't support the -L flag.
12479 # Always use the bash builtin pwd to get uniform behavior.
12480 THEPWDCMD=pwd
12481
12482 # These are not required on all platforms
12483
12484
12485 # Publish this variable in the help.
12486
12487
12488 if test "x$CYGPATH" = x; then
12489 # The variable is not set by user, try to locate tool using the code snippet
12490 for ac_prog in cygpath
12491 do
12492 # Extract the first word of "$ac_prog", so it can be a program name with args.
12493 set dummy $ac_prog; ac_word=$2
12494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12495 $as_echo_n "checking for $ac_word... " >&6; }
12496 if ${ac_cv_path_CYGPATH+:} false; then :
12497 $as_echo_n "(cached) " >&6
12498 else
12499 case $CYGPATH in
12500 [\\/]* | ?:[\\/]*)
12501 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12502 ;;
12503 *)
12504 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12505 for as_dir in $PATH
12506 do
12507 IFS=$as_save_IFS
12508 test -z "$as_dir" && as_dir=.
12509 for ac_exec_ext in '' $ac_executable_extensions; do
12510 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12511 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12512 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12513 break 2
12514 fi
12515 done
12516 done
12517 IFS=$as_save_IFS
12518
12519 ;;
12520 esac
12521 fi
12522 CYGPATH=$ac_cv_path_CYGPATH
12523 if test -n "$CYGPATH"; then
12524 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12525 $as_echo "$CYGPATH" >&6; }
12526 else
12527 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12528 $as_echo "no" >&6; }
12529 fi
12530
12531
12532 test -n "$CYGPATH" && break
12533 done
12534
12535 else
12536 # The variable is set, but is it from the command line or the environment?
12537
12538 # Try to remove the string !CYGPATH! from our list.
12539 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12540 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12541 # If it failed, the variable was not from the command line. Ignore it,
12542 # but warn the user (except for BASH, which is always set by the calling BASH).
12543 if test "xCYGPATH" != xBASH; then
12544 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12545 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12546 fi
12547 # Try to locate tool using the code snippet
12548 for ac_prog in cygpath
12549 do
12550 # Extract the first word of "$ac_prog", so it can be a program name with args.
12551 set dummy $ac_prog; ac_word=$2
12552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12553 $as_echo_n "checking for $ac_word... " >&6; }
12554 if ${ac_cv_path_CYGPATH+:} false; then :
12555 $as_echo_n "(cached) " >&6
12556 else
12557 case $CYGPATH in
12558 [\\/]* | ?:[\\/]*)
12559 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12560 ;;
12561 *)
12562 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12563 for as_dir in $PATH
12564 do
12565 IFS=$as_save_IFS
12566 test -z "$as_dir" && as_dir=.
12567 for ac_exec_ext in '' $ac_executable_extensions; do
12568 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12569 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12570 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12571 break 2
12572 fi
12573 done
12574 done
12575 IFS=$as_save_IFS
12576
12577 ;;
12578 esac
12579 fi
12580 CYGPATH=$ac_cv_path_CYGPATH
12581 if test -n "$CYGPATH"; then
12582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12583 $as_echo "$CYGPATH" >&6; }
12584 else
12585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12586 $as_echo "no" >&6; }
12587 fi
12588
12589
12590 test -n "$CYGPATH" && break
12591 done
12592
12593 else
12594 # If it succeeded, then it was overridden by the user. We will use it
12595 # for the tool.
12596
12597 # First remove it from the list of overridden variables, so we can test
12598 # for unknown variables in the end.
12599 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12600
12601 # Check if the provided tool contains a complete path.
12602 tool_specified="$CYGPATH"
12603 tool_basename="${tool_specified##*/}"
12604 if test "x$tool_basename" = "x$tool_specified"; then
12605 # A command without a complete path is provided, search $PATH.
12606 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12607 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12608 # Extract the first word of "$tool_basename", so it can be a program name with args.
12609 set dummy $tool_basename; ac_word=$2
12610 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12611 $as_echo_n "checking for $ac_word... " >&6; }
12612 if ${ac_cv_path_CYGPATH+:} false; then :
12613 $as_echo_n "(cached) " >&6
12614 else
12615 case $CYGPATH in
12616 [\\/]* | ?:[\\/]*)
12617 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12618 ;;
12619 *)
12620 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12621 for as_dir in $PATH
12622 do
12623 IFS=$as_save_IFS
12624 test -z "$as_dir" && as_dir=.
12625 for ac_exec_ext in '' $ac_executable_extensions; do
12626 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12627 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12628 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12629 break 2
12630 fi
12631 done
12632 done
12633 IFS=$as_save_IFS
12634
12635 ;;
12636 esac
12637 fi
12638 CYGPATH=$ac_cv_path_CYGPATH
12639 if test -n "$CYGPATH"; then
12640 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12641 $as_echo "$CYGPATH" >&6; }
12642 else
12643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12644 $as_echo "no" >&6; }
12645 fi
12646
12647
12648 if test "x$CYGPATH" = x; then
12649 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12650 fi
12651 else
12652 # Otherwise we believe it is a complete path. Use it as it is.
12653 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12654 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12656 $as_echo_n "checking for CYGPATH... " >&6; }
12657 if test ! -x "$tool_specified"; then
12658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12659 $as_echo "not found" >&6; }
12660 as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12661 fi
12662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12663 $as_echo "$tool_specified" >&6; }
12664 fi
12665 fi
12666 fi
12667
12668
12669
12670
12671 # Publish this variable in the help.
12672
12673
12674 if test "x$READLINK" = x; then
12675 # The variable is not set by user, try to locate tool using the code snippet
12676 for ac_prog in greadlink readlink
12677 do
12678 # Extract the first word of "$ac_prog", so it can be a program name with args.
12679 set dummy $ac_prog; ac_word=$2
12680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12681 $as_echo_n "checking for $ac_word... " >&6; }
12682 if ${ac_cv_path_READLINK+:} false; then :
12683 $as_echo_n "(cached) " >&6
12684 else
12685 case $READLINK in
12686 [\\/]* | ?:[\\/]*)
12687 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12688 ;;
12689 *)
12690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12691 for as_dir in $PATH
12692 do
12693 IFS=$as_save_IFS
12694 test -z "$as_dir" && as_dir=.
12695 for ac_exec_ext in '' $ac_executable_extensions; do
12696 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12697 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12698 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12699 break 2
12700 fi
12701 done
12702 done
12703 IFS=$as_save_IFS
12704
12705 ;;
12706 esac
12707 fi
12708 READLINK=$ac_cv_path_READLINK
12709 if test -n "$READLINK"; then
12710 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12711 $as_echo "$READLINK" >&6; }
12712 else
12713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12714 $as_echo "no" >&6; }
12715 fi
12716
12717
12718 test -n "$READLINK" && break
12719 done
12720
12721 else
12722 # The variable is set, but is it from the command line or the environment?
12723
12724 # Try to remove the string !READLINK! from our list.
12725 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12726 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12727 # If it failed, the variable was not from the command line. Ignore it,
12728 # but warn the user (except for BASH, which is always set by the calling BASH).
12729 if test "xREADLINK" != xBASH; then
12730 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12731 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12732 fi
12733 # Try to locate tool using the code snippet
12734 for ac_prog in greadlink readlink
12735 do
12736 # Extract the first word of "$ac_prog", so it can be a program name with args.
12737 set dummy $ac_prog; ac_word=$2
12738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12739 $as_echo_n "checking for $ac_word... " >&6; }
12740 if ${ac_cv_path_READLINK+:} false; then :
12741 $as_echo_n "(cached) " >&6
12742 else
12743 case $READLINK in
12744 [\\/]* | ?:[\\/]*)
12745 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12746 ;;
12747 *)
12748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12749 for as_dir in $PATH
12750 do
12751 IFS=$as_save_IFS
12752 test -z "$as_dir" && as_dir=.
12753 for ac_exec_ext in '' $ac_executable_extensions; do
12754 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12755 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12756 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12757 break 2
12758 fi
12759 done
12760 done
12761 IFS=$as_save_IFS
12762
12763 ;;
12764 esac
12765 fi
12766 READLINK=$ac_cv_path_READLINK
12767 if test -n "$READLINK"; then
12768 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12769 $as_echo "$READLINK" >&6; }
12770 else
12771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12772 $as_echo "no" >&6; }
12773 fi
12774
12775
12776 test -n "$READLINK" && break
12777 done
12778
12779 else
12780 # If it succeeded, then it was overridden by the user. We will use it
12781 # for the tool.
12782
12783 # First remove it from the list of overridden variables, so we can test
12784 # for unknown variables in the end.
12785 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12786
12787 # Check if the provided tool contains a complete path.
12788 tool_specified="$READLINK"
12789 tool_basename="${tool_specified##*/}"
12790 if test "x$tool_basename" = "x$tool_specified"; then
12791 # A command without a complete path is provided, search $PATH.
12792 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12793 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12794 # Extract the first word of "$tool_basename", so it can be a program name with args.
12795 set dummy $tool_basename; ac_word=$2
12796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12797 $as_echo_n "checking for $ac_word... " >&6; }
12798 if ${ac_cv_path_READLINK+:} false; then :
12799 $as_echo_n "(cached) " >&6
12800 else
12801 case $READLINK in
12802 [\\/]* | ?:[\\/]*)
12803 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12804 ;;
12805 *)
12806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12807 for as_dir in $PATH
12808 do
12809 IFS=$as_save_IFS
12810 test -z "$as_dir" && as_dir=.
12811 for ac_exec_ext in '' $ac_executable_extensions; do
12812 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12813 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12814 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12815 break 2
12816 fi
12817 done
12818 done
12819 IFS=$as_save_IFS
12820
12821 ;;
12822 esac
12823 fi
12824 READLINK=$ac_cv_path_READLINK
12825 if test -n "$READLINK"; then
12826 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12827 $as_echo "$READLINK" >&6; }
12828 else
12829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12830 $as_echo "no" >&6; }
12831 fi
12832
12833
12834 if test "x$READLINK" = x; then
12835 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12836 fi
12837 else
12838 # Otherwise we believe it is a complete path. Use it as it is.
12839 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12840 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12842 $as_echo_n "checking for READLINK... " >&6; }
12843 if test ! -x "$tool_specified"; then
12844 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12845 $as_echo "not found" >&6; }
12846 as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12847 fi
12848 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12849 $as_echo "$tool_specified" >&6; }
12850 fi
12851 fi
12852 fi
12853
12854
12855
12856
12857 # Publish this variable in the help.
12858
12859
12860 if test "x$DF" = x; then
12861 # The variable is not set by user, try to locate tool using the code snippet
12862 for ac_prog in df
12863 do
12864 # Extract the first word of "$ac_prog", so it can be a program name with args.
12865 set dummy $ac_prog; ac_word=$2
12866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12867 $as_echo_n "checking for $ac_word... " >&6; }
12868 if ${ac_cv_path_DF+:} false; then :
12869 $as_echo_n "(cached) " >&6
12870 else
12871 case $DF in
12872 [\\/]* | ?:[\\/]*)
12873 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12874 ;;
12875 *)
12876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12877 for as_dir in $PATH
12878 do
12879 IFS=$as_save_IFS
12880 test -z "$as_dir" && as_dir=.
12881 for ac_exec_ext in '' $ac_executable_extensions; do
12882 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12883 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12884 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12885 break 2
12886 fi
12887 done
12888 done
12889 IFS=$as_save_IFS
12890
12891 ;;
12892 esac
12893 fi
12894 DF=$ac_cv_path_DF
12895 if test -n "$DF"; then
12896 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12897 $as_echo "$DF" >&6; }
12898 else
12899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12900 $as_echo "no" >&6; }
12901 fi
12902
12903
12904 test -n "$DF" && break
12905 done
12906
12907 else
12908 # The variable is set, but is it from the command line or the environment?
12909
12910 # Try to remove the string !DF! from our list.
12911 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12912 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12913 # If it failed, the variable was not from the command line. Ignore it,
12914 # but warn the user (except for BASH, which is always set by the calling BASH).
12915 if test "xDF" != xBASH; then
12916 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12917 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12918 fi
12919 # Try to locate tool using the code snippet
12920 for ac_prog in df
12921 do
12922 # Extract the first word of "$ac_prog", so it can be a program name with args.
12923 set dummy $ac_prog; ac_word=$2
12924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12925 $as_echo_n "checking for $ac_word... " >&6; }
12926 if ${ac_cv_path_DF+:} false; then :
12927 $as_echo_n "(cached) " >&6
12928 else
12929 case $DF in
12930 [\\/]* | ?:[\\/]*)
12931 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12932 ;;
12933 *)
12934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12935 for as_dir in $PATH
12936 do
12937 IFS=$as_save_IFS
12938 test -z "$as_dir" && as_dir=.
12939 for ac_exec_ext in '' $ac_executable_extensions; do
12940 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12941 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12942 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12943 break 2
12944 fi
12945 done
12946 done
12947 IFS=$as_save_IFS
12948
12949 ;;
12950 esac
12951 fi
12952 DF=$ac_cv_path_DF
12953 if test -n "$DF"; then
12954 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12955 $as_echo "$DF" >&6; }
12956 else
12957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12958 $as_echo "no" >&6; }
12959 fi
12960
12961
12962 test -n "$DF" && break
12963 done
12964
12965 else
12966 # If it succeeded, then it was overridden by the user. We will use it
12967 # for the tool.
12968
12969 # First remove it from the list of overridden variables, so we can test
12970 # for unknown variables in the end.
12971 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12972
12973 # Check if the provided tool contains a complete path.
12974 tool_specified="$DF"
12975 tool_basename="${tool_specified##*/}"
12976 if test "x$tool_basename" = "x$tool_specified"; then
12977 # A command without a complete path is provided, search $PATH.
12978 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12979 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12980 # Extract the first word of "$tool_basename", so it can be a program name with args.
12981 set dummy $tool_basename; ac_word=$2
12982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12983 $as_echo_n "checking for $ac_word... " >&6; }
12984 if ${ac_cv_path_DF+:} false; then :
12985 $as_echo_n "(cached) " >&6
12986 else
12987 case $DF in
12988 [\\/]* | ?:[\\/]*)
12989 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12990 ;;
12991 *)
12992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12993 for as_dir in $PATH
12994 do
12995 IFS=$as_save_IFS
12996 test -z "$as_dir" && as_dir=.
12997 for ac_exec_ext in '' $ac_executable_extensions; do
12998 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12999 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13000 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13001 break 2
13002 fi
13003 done
13004 done
13005 IFS=$as_save_IFS
13006
13007 ;;
13008 esac
13009 fi
13010 DF=$ac_cv_path_DF
13011 if test -n "$DF"; then
13012 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13013 $as_echo "$DF" >&6; }
13014 else
13015 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13016 $as_echo "no" >&6; }
13017 fi
13018
13019
13020 if test "x$DF" = x; then
13021 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13022 fi
13023 else
13024 # Otherwise we believe it is a complete path. Use it as it is.
13025 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13026 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13028 $as_echo_n "checking for DF... " >&6; }
13029 if test ! -x "$tool_specified"; then
13030 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13031 $as_echo "not found" >&6; }
13032 as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13033 fi
13034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13035 $as_echo "$tool_specified" >&6; }
13036 fi
13037 fi
13038 fi
13039
13040
13041
13042
13043 # Publish this variable in the help.
13044
13045
13046 if test "x$SETFILE" = x; then
13047 # The variable is not set by user, try to locate tool using the code snippet
13048 for ac_prog in SetFile
13049 do
13050 # Extract the first word of "$ac_prog", so it can be a program name with args.
13051 set dummy $ac_prog; ac_word=$2
13052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13053 $as_echo_n "checking for $ac_word... " >&6; }
13054 if ${ac_cv_path_SETFILE+:} false; then :
13055 $as_echo_n "(cached) " >&6
13056 else
13057 case $SETFILE in
13058 [\\/]* | ?:[\\/]*)
13059 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13060 ;;
13061 *)
13062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13063 for as_dir in $PATH
13064 do
13065 IFS=$as_save_IFS
13066 test -z "$as_dir" && as_dir=.
13067 for ac_exec_ext in '' $ac_executable_extensions; do
13068 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13069 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13070 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13071 break 2
13072 fi
13073 done
13074 done
13075 IFS=$as_save_IFS
13076
13077 ;;
13078 esac
13079 fi
13080 SETFILE=$ac_cv_path_SETFILE
13081 if test -n "$SETFILE"; then
13082 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13083 $as_echo "$SETFILE" >&6; }
13084 else
13085 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13086 $as_echo "no" >&6; }
13087 fi
13088
13089
13090 test -n "$SETFILE" && break
13091 done
13092
13093 else
13094 # The variable is set, but is it from the command line or the environment?
13095
13096 # Try to remove the string !SETFILE! from our list.
13097 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13098 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13099 # If it failed, the variable was not from the command line. Ignore it,
13100 # but warn the user (except for BASH, which is always set by the calling BASH).
13101 if test "xSETFILE" != xBASH; then
13102 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13103 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13104 fi
13105 # Try to locate tool using the code snippet
13106 for ac_prog in SetFile
13107 do
13108 # Extract the first word of "$ac_prog", so it can be a program name with args.
13109 set dummy $ac_prog; ac_word=$2
13110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13111 $as_echo_n "checking for $ac_word... " >&6; }
13112 if ${ac_cv_path_SETFILE+:} false; then :
13113 $as_echo_n "(cached) " >&6
13114 else
13115 case $SETFILE in
13116 [\\/]* | ?:[\\/]*)
13117 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13118 ;;
13119 *)
13120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13121 for as_dir in $PATH
13122 do
13123 IFS=$as_save_IFS
13124 test -z "$as_dir" && as_dir=.
13125 for ac_exec_ext in '' $ac_executable_extensions; do
13126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13127 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13129 break 2
13130 fi
13131 done
13132 done
13133 IFS=$as_save_IFS
13134
13135 ;;
13136 esac
13137 fi
13138 SETFILE=$ac_cv_path_SETFILE
13139 if test -n "$SETFILE"; then
13140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13141 $as_echo "$SETFILE" >&6; }
13142 else
13143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13144 $as_echo "no" >&6; }
13145 fi
13146
13147
13148 test -n "$SETFILE" && break
13149 done
13150
13151 else
13152 # If it succeeded, then it was overridden by the user. We will use it
13153 # for the tool.
13154
13155 # First remove it from the list of overridden variables, so we can test
13156 # for unknown variables in the end.
13157 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13158
13159 # Check if the provided tool contains a complete path.
13160 tool_specified="$SETFILE"
13161 tool_basename="${tool_specified##*/}"
13162 if test "x$tool_basename" = "x$tool_specified"; then
13163 # A command without a complete path is provided, search $PATH.
13164 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13165 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13166 # Extract the first word of "$tool_basename", so it can be a program name with args.
13167 set dummy $tool_basename; ac_word=$2
13168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13169 $as_echo_n "checking for $ac_word... " >&6; }
13170 if ${ac_cv_path_SETFILE+:} false; then :
13171 $as_echo_n "(cached) " >&6
13172 else
13173 case $SETFILE in
13174 [\\/]* | ?:[\\/]*)
13175 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13176 ;;
13177 *)
13178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13179 for as_dir in $PATH
13180 do
13181 IFS=$as_save_IFS
13182 test -z "$as_dir" && as_dir=.
13183 for ac_exec_ext in '' $ac_executable_extensions; do
13184 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13185 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13186 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13187 break 2
13188 fi
13189 done
13190 done
13191 IFS=$as_save_IFS
13192
13193 ;;
13194 esac
13195 fi
13196 SETFILE=$ac_cv_path_SETFILE
13197 if test -n "$SETFILE"; then
13198 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13199 $as_echo "$SETFILE" >&6; }
13200 else
13201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13202 $as_echo "no" >&6; }
13203 fi
13204
13205
13206 if test "x$SETFILE" = x; then
13207 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13208 fi
13209 else
13210 # Otherwise we believe it is a complete path. Use it as it is.
13211 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13212 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13213 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13214 $as_echo_n "checking for SETFILE... " >&6; }
13215 if test ! -x "$tool_specified"; then
13216 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13217 $as_echo "not found" >&6; }
13218 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13219 fi
13220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13221 $as_echo "$tool_specified" >&6; }
13222 fi
13223 fi
13224 fi
13225
13226
13227
13228
13229 # Publish this variable in the help.
13230
13231
13232 if test "x$CPIO" = x; then
13233 # The variable is not set by user, try to locate tool using the code snippet
13234 for ac_prog in cpio bsdcpio
13235 do
13236 # Extract the first word of "$ac_prog", so it can be a program name with args.
13237 set dummy $ac_prog; ac_word=$2
13238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13239 $as_echo_n "checking for $ac_word... " >&6; }
13240 if ${ac_cv_path_CPIO+:} false; then :
13241 $as_echo_n "(cached) " >&6
13242 else
13243 case $CPIO in
13244 [\\/]* | ?:[\\/]*)
13245 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13246 ;;
13247 *)
13248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13249 for as_dir in $PATH
13250 do
13251 IFS=$as_save_IFS
13252 test -z "$as_dir" && as_dir=.
13253 for ac_exec_ext in '' $ac_executable_extensions; do
13254 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13255 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13256 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13257 break 2
13258 fi
13259 done
13260 done
13261 IFS=$as_save_IFS
13262
13263 ;;
13264 esac
13265 fi
13266 CPIO=$ac_cv_path_CPIO
13267 if test -n "$CPIO"; then
13268 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13269 $as_echo "$CPIO" >&6; }
13270 else
13271 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13272 $as_echo "no" >&6; }
13273 fi
13274
13275
13276 test -n "$CPIO" && break
13277 done
13278
13279 else
13280 # The variable is set, but is it from the command line or the environment?
13281
13282 # Try to remove the string !CPIO! from our list.
13283 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13284 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13285 # If it failed, the variable was not from the command line. Ignore it,
13286 # but warn the user (except for BASH, which is always set by the calling BASH).
13287 if test "xCPIO" != xBASH; then
13288 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13289 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13290 fi
13291 # Try to locate tool using the code snippet
13292 for ac_prog in cpio bsdcpio
13293 do
13294 # Extract the first word of "$ac_prog", so it can be a program name with args.
13295 set dummy $ac_prog; ac_word=$2
13296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13297 $as_echo_n "checking for $ac_word... " >&6; }
13298 if ${ac_cv_path_CPIO+:} false; then :
13299 $as_echo_n "(cached) " >&6
13300 else
13301 case $CPIO in
13302 [\\/]* | ?:[\\/]*)
13303 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13304 ;;
13305 *)
13306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13307 for as_dir in $PATH
13308 do
13309 IFS=$as_save_IFS
13310 test -z "$as_dir" && as_dir=.
13311 for ac_exec_ext in '' $ac_executable_extensions; do
13312 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13313 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13314 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13315 break 2
13316 fi
13317 done
13318 done
13319 IFS=$as_save_IFS
13320
13321 ;;
13322 esac
13323 fi
13324 CPIO=$ac_cv_path_CPIO
13325 if test -n "$CPIO"; then
13326 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13327 $as_echo "$CPIO" >&6; }
13328 else
13329 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13330 $as_echo "no" >&6; }
13331 fi
13332
13333
13334 test -n "$CPIO" && break
13335 done
13336
13337 else
13338 # If it succeeded, then it was overridden by the user. We will use it
13339 # for the tool.
13340
13341 # First remove it from the list of overridden variables, so we can test
13342 # for unknown variables in the end.
13343 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13344
13345 # Check if the provided tool contains a complete path.
13346 tool_specified="$CPIO"
13347 tool_basename="${tool_specified##*/}"
13348 if test "x$tool_basename" = "x$tool_specified"; then
13349 # A command without a complete path is provided, search $PATH.
13350 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13351 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13352 # Extract the first word of "$tool_basename", so it can be a program name with args.
13353 set dummy $tool_basename; ac_word=$2
13354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13355 $as_echo_n "checking for $ac_word... " >&6; }
13356 if ${ac_cv_path_CPIO+:} false; then :
13357 $as_echo_n "(cached) " >&6
13358 else
13359 case $CPIO in
13360 [\\/]* | ?:[\\/]*)
13361 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13362 ;;
13363 *)
13364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13365 for as_dir in $PATH
13366 do
13367 IFS=$as_save_IFS
13368 test -z "$as_dir" && as_dir=.
13369 for ac_exec_ext in '' $ac_executable_extensions; do
13370 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13371 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13372 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13373 break 2
13374 fi
13375 done
13376 done
13377 IFS=$as_save_IFS
13378
13379 ;;
13380 esac
13381 fi
13382 CPIO=$ac_cv_path_CPIO
13383 if test -n "$CPIO"; then
13384 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13385 $as_echo "$CPIO" >&6; }
13386 else
13387 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13388 $as_echo "no" >&6; }
13389 fi
13390
13391
13392 if test "x$CPIO" = x; then
13393 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13394 fi
13395 else
13396 # Otherwise we believe it is a complete path. Use it as it is.
13397 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13398 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13400 $as_echo_n "checking for CPIO... " >&6; }
13401 if test ! -x "$tool_specified"; then
13402 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13403 $as_echo "not found" >&6; }
13404 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13405 fi
13406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13407 $as_echo "$tool_specified" >&6; }
13408 fi
13409 fi
13410 fi
13411
13412
13413
13414
13415 # Now we can determine OpenJDK build and target platforms. This is required to
13416 # have early on.
13417 # Make sure we can run config.sub.
13418 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13419 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13420
13421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13422 $as_echo_n "checking build system type... " >&6; }
13423 if ${ac_cv_build+:} false; then :
13424 $as_echo_n "(cached) " >&6
13425 else
13426 ac_build_alias=$build_alias
13427 test "x$ac_build_alias" = x &&
13428 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13429 test "x$ac_build_alias" = x &&
13430 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13431 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13432 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13433
13434 fi
13435 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13436 $as_echo "$ac_cv_build" >&6; }
13437 case $ac_cv_build in
13438 *-*-*) ;;
13439 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13440 esac
13441 build=$ac_cv_build
13442 ac_save_IFS=$IFS; IFS='-'
13443 set x $ac_cv_build
13444 shift
13445 build_cpu=$1
13446 build_vendor=$2
13447 shift; shift
13448 # Remember, the first character of IFS is used to create $*,
13449 # except with old shells:
13450 build_os=$*
13451 IFS=$ac_save_IFS
13452 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13453
13454
13455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13456 $as_echo_n "checking host system type... " >&6; }
13457 if ${ac_cv_host+:} false; then :
13458 $as_echo_n "(cached) " >&6
13459 else
13460 if test "x$host_alias" = x; then
13461 ac_cv_host=$ac_cv_build
13462 else
13463 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13464 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13465 fi
13466
13467 fi
13468 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13469 $as_echo "$ac_cv_host" >&6; }
13470 case $ac_cv_host in
13471 *-*-*) ;;
13472 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13473 esac
13474 host=$ac_cv_host
13475 ac_save_IFS=$IFS; IFS='-'
13476 set x $ac_cv_host
13477 shift
13478 host_cpu=$1
13479 host_vendor=$2
13480 shift; shift
13481 # Remember, the first character of IFS is used to create $*,
13482 # except with old shells:
13483 host_os=$*
13484 IFS=$ac_save_IFS
13485 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13486
13487
13488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13489 $as_echo_n "checking target system type... " >&6; }
13490 if ${ac_cv_target+:} false; then :
13491 $as_echo_n "(cached) " >&6
13492 else
13493 if test "x$target_alias" = x; then
13494 ac_cv_target=$ac_cv_host
13495 else
13496 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13497 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13498 fi
13499
13500 fi
13501 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13502 $as_echo "$ac_cv_target" >&6; }
13503 case $ac_cv_target in
13504 *-*-*) ;;
13505 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13506 esac
13507 target=$ac_cv_target
13508 ac_save_IFS=$IFS; IFS='-'
13509 set x $ac_cv_target
13510 shift
13511 target_cpu=$1
13512 target_vendor=$2
13513 shift; shift
13514 # Remember, the first character of IFS is used to create $*,
13515 # except with old shells:
13516 target_os=$*
13517 IFS=$ac_save_IFS
13518 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13519
13520
13521 # The aliases save the names the user supplied, while $host etc.
13522 # will get canonicalized.
13523 test -n "$target_alias" &&
13524 test "$program_prefix$program_suffix$program_transform_name" = \
13525 NONENONEs,x,x, &&
13526 program_prefix=${target_alias}-
13527
13528 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13529 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
13530 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13531 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13532 # to use the configure naming style.
13533
13534
13535
13536
13537
13538 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13539 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13540 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13541 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13542 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13543 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13544
13545
13546
13547 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13548
13549 case "$build_os" in
13550 *linux*)
13551 VAR_OS=linux
13552 VAR_OS_TYPE=unix
13553 ;;
13554 *solaris*)
13555 VAR_OS=solaris
13556 VAR_OS_TYPE=unix
13557 ;;
13558 *darwin*)
13559 VAR_OS=macosx
13560 VAR_OS_TYPE=unix
13561 ;;
13562 *bsd*)
13563 VAR_OS=bsd
13564 VAR_OS_TYPE=unix
13565 ;;
13566 *cygwin*)
13567 VAR_OS=windows
13568 VAR_OS_ENV=windows.cygwin
13569 ;;
13570 *mingw*)
13571 VAR_OS=windows
13572 VAR_OS_ENV=windows.msys
13573 ;;
13574 *aix*)
13575 VAR_OS=aix
13576 VAR_OS_TYPE=unix
13577 ;;
13578 *)
13579 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13580 ;;
13581 esac
13582
13583
13584 # First argument is the cpu name from the trip/quad
13585 case "$build_cpu" in
13586 x86_64)
13587 VAR_CPU=x86_64
13588 VAR_CPU_ARCH=x86
13589 VAR_CPU_BITS=64
13590 VAR_CPU_ENDIAN=little
13591 ;;
13592 i?86)
13593 VAR_CPU=x86
13594 VAR_CPU_ARCH=x86
13595 VAR_CPU_BITS=32
13596 VAR_CPU_ENDIAN=little
13597 ;;
13598 arm*)
13599 VAR_CPU=arm
13600 VAR_CPU_ARCH=arm
13601 VAR_CPU_BITS=32
13602 VAR_CPU_ENDIAN=little
13603 ;;
13604 aarch64)
13605 VAR_CPU=aarch64
13606 VAR_CPU_ARCH=aarch64
13607 VAR_CPU_BITS=64
13608 VAR_CPU_ENDIAN=little
13609 ;;
13610 powerpc)
13611 VAR_CPU=ppc
13612 VAR_CPU_ARCH=ppc
13613 VAR_CPU_BITS=32
13614 VAR_CPU_ENDIAN=big
13615 ;;
13616 powerpc64)
13617 VAR_CPU=ppc64
13618 VAR_CPU_ARCH=ppc
13619 VAR_CPU_BITS=64
13620 VAR_CPU_ENDIAN=big
13621 ;;
13622 powerpc64le)
13623 VAR_CPU=ppc64
13624 VAR_CPU_ARCH=ppc
13625 VAR_CPU_BITS=64
13626 VAR_CPU_ENDIAN=little
13627 ;;
13628 s390)
13629 VAR_CPU=s390
13630 VAR_CPU_ARCH=s390
13631 VAR_CPU_BITS=32
13632 VAR_CPU_ENDIAN=big
13633 ;;
13634 s390x)
13635 VAR_CPU=s390x
13636 VAR_CPU_ARCH=s390
13637 VAR_CPU_BITS=64
13638 VAR_CPU_ENDIAN=big
13639 ;;
13640 sparc)
13641 VAR_CPU=sparc
13642 VAR_CPU_ARCH=sparc
13643 VAR_CPU_BITS=32
13644 VAR_CPU_ENDIAN=big
13645 ;;
13646 sparcv9|sparc64)
13647 VAR_CPU=sparcv9
13648 VAR_CPU_ARCH=sparc
13649 VAR_CPU_BITS=64
13650 VAR_CPU_ENDIAN=big
13651 ;;
13652 *)
13653 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13654 ;;
13655 esac
13656
13657 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13658 OPENJDK_BUILD_OS="$VAR_OS"
13659 if test "x$VAR_OS_TYPE" != x; then
13660 OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13661 else
13662 OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13663 fi
13664 if test "x$VAR_OS_ENV" != x; then
13665 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13666 else
13667 OPENJDK_BUILD_OS_ENV="$VAR_OS"
13668 fi
13669 OPENJDK_BUILD_CPU="$VAR_CPU"
13670 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13671 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13672 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13673
13674
13675
13676
13677
13678
13679
13680
13681 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13682 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13683 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13684 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13685
13686 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13687
13688 case "$host_os" in
13689 *linux*)
13690 VAR_OS=linux
13691 VAR_OS_TYPE=unix
13692 ;;
13693 *solaris*)
13694 VAR_OS=solaris
13695 VAR_OS_TYPE=unix
13696 ;;
13697 *darwin*)
13698 VAR_OS=macosx
13699 VAR_OS_TYPE=unix
13700 ;;
13701 *bsd*)
13702 VAR_OS=bsd
13703 VAR_OS_TYPE=unix
13704 ;;
13705 *cygwin*)
13706 VAR_OS=windows
13707 VAR_OS_ENV=windows.cygwin
13708 ;;
13709 *mingw*)
13710 VAR_OS=windows
13711 VAR_OS_ENV=windows.msys
13712 ;;
13713 *aix*)
13714 VAR_OS=aix
13715 VAR_OS_TYPE=unix
13716 ;;
13717 *)
13718 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13719 ;;
13720 esac
13721
13722
13723 # First argument is the cpu name from the trip/quad
13724 case "$host_cpu" in
13725 x86_64)
13726 VAR_CPU=x86_64
13727 VAR_CPU_ARCH=x86
13728 VAR_CPU_BITS=64
13729 VAR_CPU_ENDIAN=little
13730 ;;
13731 i?86)
13732 VAR_CPU=x86
13733 VAR_CPU_ARCH=x86
13734 VAR_CPU_BITS=32
13735 VAR_CPU_ENDIAN=little
13736 ;;
13737 arm*)
13738 VAR_CPU=arm
13739 VAR_CPU_ARCH=arm
13740 VAR_CPU_BITS=32
13741 VAR_CPU_ENDIAN=little
13742 ;;
13743 aarch64)
13744 VAR_CPU=aarch64
13745 VAR_CPU_ARCH=aarch64
13746 VAR_CPU_BITS=64
13747 VAR_CPU_ENDIAN=little
13748 ;;
13749 powerpc)
13750 VAR_CPU=ppc
13751 VAR_CPU_ARCH=ppc
13752 VAR_CPU_BITS=32
13753 VAR_CPU_ENDIAN=big
13754 ;;
13755 powerpc64)
13756 VAR_CPU=ppc64
13757 VAR_CPU_ARCH=ppc
13758 VAR_CPU_BITS=64
13759 VAR_CPU_ENDIAN=big
13760 ;;
13761 powerpc64le)
13762 VAR_CPU=ppc64
13763 VAR_CPU_ARCH=ppc
13764 VAR_CPU_BITS=64
13765 VAR_CPU_ENDIAN=little
13766 ;;
13767 s390)
13768 VAR_CPU=s390
13769 VAR_CPU_ARCH=s390
13770 VAR_CPU_BITS=32
13771 VAR_CPU_ENDIAN=big
13772 ;;
13773 s390x)
13774 VAR_CPU=s390x
13775 VAR_CPU_ARCH=s390
13776 VAR_CPU_BITS=64
13777 VAR_CPU_ENDIAN=big
13778 ;;
13779 sparc)
13780 VAR_CPU=sparc
13781 VAR_CPU_ARCH=sparc
13782 VAR_CPU_BITS=32
13783 VAR_CPU_ENDIAN=big
13784 ;;
13785 sparcv9|sparc64)
13786 VAR_CPU=sparcv9
13787 VAR_CPU_ARCH=sparc
13788 VAR_CPU_BITS=64
13789 VAR_CPU_ENDIAN=big
13790 ;;
13791 *)
13792 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13793 ;;
13794 esac
13795
13796 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13797 OPENJDK_TARGET_OS="$VAR_OS"
13798 if test "x$VAR_OS_TYPE" != x; then
13799 OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13800 else
13801 OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13802 fi
13803 if test "x$VAR_OS_ENV" != x; then
13804 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13805 else
13806 OPENJDK_TARGET_OS_ENV="$VAR_OS"
13807 fi
13808 OPENJDK_TARGET_CPU="$VAR_CPU"
13809 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13810 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13811 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13812
13813
13814
13815
13816
13817
13818
13819
13820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13821 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13822 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13823 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13824
13825
13826
13827 # Check whether --with-target-bits was given.
13828 if test "${with_target_bits+set}" = set; then :
13829 withval=$with_target_bits;
13830 fi
13831
13832
13833 # We have three types of compiles:
13834 # native == normal compilation, target system == build system
13835 # cross == traditional cross compilation, target system != build system; special toolchain needed
13836 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13837 #
13838 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13839 # We're doing a proper cross-compilation
13840 COMPILE_TYPE="cross"
13841 else
13842 COMPILE_TYPE="native"
13843 fi
13844
13845 if test "x$with_target_bits" != x; then
13846 if test "x$COMPILE_TYPE" = "xcross"; then
13847 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13848 fi
13849
13850 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13851 # A reduced build is requested
13852 COMPILE_TYPE="reduced"
13853 OPENJDK_TARGET_CPU_BITS=32
13854 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13855 OPENJDK_TARGET_CPU=x86
13856 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13857 OPENJDK_TARGET_CPU=sparc
13858 else
13859 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13860 fi
13861 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13862 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
13863 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13864 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13865 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13866 else
13867 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13868 fi
13869 fi
13870
13871
13872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13873 $as_echo_n "checking compilation type... " >&6; }
13874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13875 $as_echo "$COMPILE_TYPE" >&6; }
13876
13877
13878 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13879 REQUIRED_OS_NAME=SunOS
13880 REQUIRED_OS_VERSION=5.10
13881 fi
13882 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13883 REQUIRED_OS_NAME=Linux
13884 REQUIRED_OS_VERSION=2.6
13885 fi
13886 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13887 REQUIRED_OS_NAME=Windows
13888 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13889 REQUIRED_OS_VERSION=5.2
13890 else
13891 REQUIRED_OS_VERSION=5.1
13892 fi
13893 fi
13894 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13895 REQUIRED_OS_NAME=Darwin
13896 REQUIRED_OS_VERSION=11.2
13897 fi
13898
13899
13900
13901
13902
13903 # Also store the legacy naming of the cpu.
13904 # Ie i586 and amd64 instead of x86 and x86_64
13905 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13906 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13907 OPENJDK_TARGET_CPU_LEGACY="i586"
13908 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13909 # On all platforms except MacOSX replace x86_64 with amd64.
13910 OPENJDK_TARGET_CPU_LEGACY="amd64"
13911 fi
13912
13913
13914 # And the second legacy naming of the cpu.
13915 # Ie i386 and amd64 instead of x86 and x86_64.
13916 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13917 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13918 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13919 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13920 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13921 fi
13922
13923
13924 # This is the name of the cpu (but using i386 and amd64 instead of
13925 # x86 and x86_64, respectively), preceeded by a /, to be used when
13926 # locating libraries. On macosx, it's empty, though.
13927 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13928 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13929 OPENJDK_TARGET_CPU_LIBDIR=""
13930 fi
13931
13932
13933 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13934 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13935 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13936 OPENJDK_TARGET_CPU_ISADIR=""
13937 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13938 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13939 OPENJDK_TARGET_CPU_ISADIR="/amd64"
13940 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13941 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13942 fi
13943 fi
13944
13945
13946 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13947 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13948 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13949 # On linux only, we replace x86 with i386.
13950 OPENJDK_TARGET_CPU_OSARCH="i386"
13951 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13952 # On all platforms except macosx, we replace x86_64 with amd64.
13953 OPENJDK_TARGET_CPU_OSARCH="amd64"
13954 fi
13955
13956
13957 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13958 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13959 OPENJDK_TARGET_CPU_JLI="i386"
13960 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13961 # On all platforms except macosx, we replace x86_64 with amd64.
13962 OPENJDK_TARGET_CPU_JLI="amd64"
13963 fi
13964 # Now setup the -D flags for building libjli.
13965 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13966 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13967 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13968 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13969 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13970 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13971 fi
13972 fi
13973
13974
13975 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13976 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13977 else
13978 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
13979 fi
13980
13981
13982 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13983 A_LP64="LP64:="
13984 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13985 # unpack200.exe
13986 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13987 ADD_LP64="-D_LP64=1"
13988 fi
13989 fi
13990 LP64=$A_LP64
13991
13992
13993 if test "x$COMPILE_TYPE" = "xcross"; then
13994 # FIXME: ... or should this include reduced builds..?
13995 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13996 else
13997 DEFINE_CROSS_COMPILE_ARCH=""
13998 fi
13999
14000
14001 # ZERO_ARCHDEF is used to enable architecture-specific code
14002 case "${OPENJDK_TARGET_CPU}" in
14003 ppc) ZERO_ARCHDEF=PPC32 ;;
14004 ppc64) ZERO_ARCHDEF=PPC64 ;;
14005 s390*) ZERO_ARCHDEF=S390 ;;
14006 sparc*) ZERO_ARCHDEF=SPARC ;;
14007 x86_64*) ZERO_ARCHDEF=AMD64 ;;
14008 x86) ZERO_ARCHDEF=IA32 ;;
14009 *) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14010 esac
14011
14012
14013
14014
14015 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14016
14017 # Save the current directory this script was started from
14018 CURDIR="$PWD"
14019
14020 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14021 PATH_SEP=";"
14022
14023 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14024 if test $SRC_ROOT_LENGTH -gt 100; then
14025 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14026 fi
14027
14028 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14029 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14030 $as_echo_n "checking cygwin release... " >&6; }
14031 CYGWIN_VERSION=`$UNAME -r`
14032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14033 $as_echo "$CYGWIN_VERSION" >&6; }
14034 WINDOWS_ENV_VENDOR='cygwin'
14035 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14036
14037 CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
14038 if test "x$CYGWIN_VERSION_OK" = x; then
14039 { $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
14040 $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;}
14041 as_fn_error $? "Cannot continue" "$LINENO" 5
14042 fi
14043 if test "x$CYGPATH" = x; then
14044 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14045 fi
14046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14047 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14048 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14049 cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
14050 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14051 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14052 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14053 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14054 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14055 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14056 if test "x$test_cygdrive_prefix" = x; then
14057 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14058 fi
14059 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14060 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14061 $as_echo_n "checking msys release... " >&6; }
14062 MSYS_VERSION=`$UNAME -r`
14063 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14064 $as_echo "$MSYS_VERSION" >&6; }
14065
14066 WINDOWS_ENV_VENDOR='msys'
14067 WINDOWS_ENV_VERSION="$MSYS_VERSION"
14068
14069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14070 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14071 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14072 MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14073
14074 windows_path="$MSYS_ROOT_PATH"
14075 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14076 unix_path=`$CYGPATH -u "$windows_path"`
14077 MSYS_ROOT_PATH="$unix_path"
14078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14079 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14080 MSYS_ROOT_PATH="$unix_path"
14081 fi
14082
14083 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14084 $as_echo "$MSYS_ROOT_PATH" >&6; }
14085 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14086 else
14087 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14088 fi
14089
14090 # Test if windows or unix (cygwin/msys) find is first in path.
14091 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14092 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14093 FIND_BINARY_OUTPUT=`find --version 2>&1`
14094 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14095 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14096 $as_echo "unix style" >&6; }
14097 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14098 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14099 $as_echo "Windows" >&6; }
14100 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14101 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14102 { $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
14103 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14104 as_fn_error $? "Cannot continue" "$LINENO" 5
14105 else
14106 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14107 $as_echo "unknown" >&6; }
14108 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14109 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14110 fi
14111
14112 else
14113 PATH_SEP=":"
14114 fi
14115
14116
14117 # We get the top-level directory from the supporting wrappers.
14118 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14119 $as_echo_n "checking for top-level directory... " >&6; }
14120 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14121 $as_echo "$TOPDIR" >&6; }
14122
14123
14124 # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14125
14126 # Only process if variable expands to non-empty
14127
14128 if test "x$CURDIR" != x; then
14129 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14130
14131 # Input might be given as Windows format, start by converting to
14132 # unix format.
14133 path="$CURDIR"
14134 new_path=`$CYGPATH -u "$path"`
14135
14136 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14137 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14138 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14139 # "foo.exe" is OK but "foo" is an error.
14140 #
14141 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14142 # It is also a way to make sure we got the proper file name for the real test later on.
14143 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14144 if test "x$test_shortpath" = x; then
14145 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14146 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14147 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14148 fi
14149
14150 # Call helper function which possibly converts this using DOS-style short mode.
14151 # If so, the updated path is stored in $new_path.
14152
14153 input_path="$new_path"
14154 # Check if we need to convert this using DOS-style short mode. If the path
14155 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14156 # take no chances and rewrite it.
14157 # Note: m4 eats our [], so we need to use [ and ] instead.
14158 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14159 if test "x$has_forbidden_chars" != x; then
14160 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14161 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14162 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14163 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14164 # Going to short mode and back again did indeed matter. Since short mode is
14165 # case insensitive, let's make it lowercase to improve readability.
14166 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14167 # Now convert it back to Unix-stile (cygpath)
14168 input_path=`$CYGPATH -u "$shortmode_path"`
14169 new_path="$input_path"
14170 fi
14171 fi
14172
14173 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14174 if test "x$test_cygdrive_prefix" = x; then
14175 # As a simple fix, exclude /usr/bin since it's not a real path.
14176 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14177 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14178 # a path prefixed by /cygdrive for fixpath to work.
14179 new_path="$CYGWIN_ROOT_PATH$input_path"
14180 fi
14181 fi
14182
14183
14184 if test "x$path" != "x$new_path"; then
14185 CURDIR="$new_path"
14186 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14187 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14188 fi
14189
14190 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14191
14192 path="$CURDIR"
14193 has_colon=`$ECHO $path | $GREP ^.:`
14194 new_path="$path"
14195 if test "x$has_colon" = x; then
14196 # Not in mixed or Windows style, start by that.
14197 new_path=`cmd //c echo $path`
14198 fi
14199
14200
14201 input_path="$new_path"
14202 # Check if we need to convert this using DOS-style short mode. If the path
14203 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14204 # take no chances and rewrite it.
14205 # Note: m4 eats our [], so we need to use [ and ] instead.
14206 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14207 if test "x$has_forbidden_chars" != x; then
14208 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14209 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14210 fi
14211
14212
14213 windows_path="$new_path"
14214 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14215 unix_path=`$CYGPATH -u "$windows_path"`
14216 new_path="$unix_path"
14217 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14218 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14219 new_path="$unix_path"
14220 fi
14221
14222 if test "x$path" != "x$new_path"; then
14223 CURDIR="$new_path"
14224 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14225 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14226 fi
14227
14228 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14229 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14230
14231 else
14232 # We're on a unix platform. Hooray! :)
14233 path="$CURDIR"
14234 has_space=`$ECHO "$path" | $GREP " "`
14235 if test "x$has_space" != x; then
14236 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14237 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14238 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14239 fi
14240
14241 # Use eval to expand a potential ~
14242 eval path="$path"
14243 if test ! -f "$path" && test ! -d "$path"; then
14244 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14245 fi
14246
14247 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14248 fi
14249 fi
14250
14251
14252 # Only process if variable expands to non-empty
14253
14254 if test "x$TOPDIR" != x; then
14255 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14256
14257 # Input might be given as Windows format, start by converting to
14258 # unix format.
14259 path="$TOPDIR"
14260 new_path=`$CYGPATH -u "$path"`
14261
14262 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14263 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14264 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14265 # "foo.exe" is OK but "foo" is an error.
14266 #
14267 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14268 # It is also a way to make sure we got the proper file name for the real test later on.
14269 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14270 if test "x$test_shortpath" = x; then
14271 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14272 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14273 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14274 fi
14275
14276 # Call helper function which possibly converts this using DOS-style short mode.
14277 # If so, the updated path is stored in $new_path.
14278
14279 input_path="$new_path"
14280 # Check if we need to convert this using DOS-style short mode. If the path
14281 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14282 # take no chances and rewrite it.
14283 # Note: m4 eats our [], so we need to use [ and ] instead.
14284 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14285 if test "x$has_forbidden_chars" != x; then
14286 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14287 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14288 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14289 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14290 # Going to short mode and back again did indeed matter. Since short mode is
14291 # case insensitive, let's make it lowercase to improve readability.
14292 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14293 # Now convert it back to Unix-stile (cygpath)
14294 input_path=`$CYGPATH -u "$shortmode_path"`
14295 new_path="$input_path"
14296 fi
14297 fi
14298
14299 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14300 if test "x$test_cygdrive_prefix" = x; then
14301 # As a simple fix, exclude /usr/bin since it's not a real path.
14302 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14303 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14304 # a path prefixed by /cygdrive for fixpath to work.
14305 new_path="$CYGWIN_ROOT_PATH$input_path"
14306 fi
14307 fi
14308
14309
14310 if test "x$path" != "x$new_path"; then
14311 TOPDIR="$new_path"
14312 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14313 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14314 fi
14315
14316 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14317
14318 path="$TOPDIR"
14319 has_colon=`$ECHO $path | $GREP ^.:`
14320 new_path="$path"
14321 if test "x$has_colon" = x; then
14322 # Not in mixed or Windows style, start by that.
14323 new_path=`cmd //c echo $path`
14324 fi
14325
14326
14327 input_path="$new_path"
14328 # Check if we need to convert this using DOS-style short mode. If the path
14329 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14330 # take no chances and rewrite it.
14331 # Note: m4 eats our [], so we need to use [ and ] instead.
14332 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14333 if test "x$has_forbidden_chars" != x; then
14334 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14335 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14336 fi
14337
14338
14339 windows_path="$new_path"
14340 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14341 unix_path=`$CYGPATH -u "$windows_path"`
14342 new_path="$unix_path"
14343 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14344 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14345 new_path="$unix_path"
14346 fi
14347
14348 if test "x$path" != "x$new_path"; then
14349 TOPDIR="$new_path"
14350 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14351 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14352 fi
14353
14354 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14355 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14356
14357 else
14358 # We're on a unix platform. Hooray! :)
14359 path="$TOPDIR"
14360 has_space=`$ECHO "$path" | $GREP " "`
14361 if test "x$has_space" != x; then
14362 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14363 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14364 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14365 fi
14366
14367 # Use eval to expand a potential ~
14368 eval path="$path"
14369 if test ! -f "$path" && test ! -d "$path"; then
14370 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14371 fi
14372
14373 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14374 fi
14375 fi
14376
14377 # SRC_ROOT is a traditional alias for TOPDIR.
14378 SRC_ROOT=$TOPDIR
14379
14380 # Locate the directory of this script.
14381 AUTOCONF_DIR=$TOPDIR/common/autoconf
14382
14383
14384 # Setup default logging of stdout and stderr to build.log in the output root.
14385 BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14386 BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14387 BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14388
14389
14390
14391
14392
14393 # Check if it's a pure open build or if custom sources are to be used.
14394
14395 # Check whether --enable-openjdk-only was given.
14396 if test "${enable_openjdk_only+set}" = set; then :
14397 enableval=$enable_openjdk_only;
14398 else
14399 enable_openjdk_only="no"
14400 fi
14401
14402
14403 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14404 $as_echo_n "checking for presence of closed sources... " >&6; }
14405 if test -d "$SRC_ROOT/jdk/src/closed"; then
14406 CLOSED_SOURCE_PRESENT=yes
14407 else
14408 CLOSED_SOURCE_PRESENT=no
14409 fi
14410 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14411 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14412
14413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14414 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14415 SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14416 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14417 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14418
14419 if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14420 OPENJDK=true
14421 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14422 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14423 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14424 fi
14425 else
14426 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14427 OPENJDK=true
14428 else
14429 OPENJDK=false
14430 fi
14431 fi
14432
14433 if test "x$OPENJDK" = "xtrue"; then
14434 SET_OPENJDK="OPENJDK=true"
14435 fi
14436
14437
14438
14439 # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14440 # the IncludeCustomExtension macro.
14441
14442
14443 # Check whether --with-custom-make-dir was given.
14444 if test "${with_custom_make_dir+set}" = set; then :
14445 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
14446 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14447 fi
14448
14449
14450
14451
14452 # These are needed to be able to create a configuration name (and thus the output directory)
14453
14454 ###############################################################################
14455 #
14456 # Check which variant of the JDK that we want to build.
14457 # Currently we have:
14458 # normal: standard edition
14459 # but the custom make system may add other variants
14460 #
14461 # Effectively the JDK variant gives a name to a specific set of
14462 # modules to compile into the JDK. In the future, these modules
14463 # might even be Jigsaw modules.
14464 #
14465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14466 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14467
14468 # Check whether --with-jdk-variant was given.
14469 if test "${with_jdk_variant+set}" = set; then :
14470 withval=$with_jdk_variant;
14471 fi
14472
14473
14474 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14475 JDK_VARIANT="normal"
14476 else
14477 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14478 fi
14479
14480
14481
14482 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14483 $as_echo "$JDK_VARIANT" >&6; }
14484
14485
14486 ###############################################################################
14487 #
14488 # Check which interpreter of the JVM we want to build.
14489 # Currently we have:
14490 # template: Template interpreter (the default)
14491 # cpp : C++ interpreter
14492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14493 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14494
14495 # Check whether --with-jvm-interpreter was given.
14496 if test "${with_jvm_interpreter+set}" = set; then :
14497 withval=$with_jvm_interpreter;
14498 fi
14499
14500
14501 if test "x$with_jvm_interpreter" = x; then
14502 with_jvm_interpreter="template"
14503 fi
14504
14505 JVM_INTERPRETER="$with_jvm_interpreter"
14506
14507 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14508 as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14509 fi
14510
14511
14512
14513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14514 $as_echo "$with_jvm_interpreter" >&6; }
14515
14516
14517
14518 ###############################################################################
14519 #
14520 # Check which variants of the JVM that we want to build.
14521 # Currently we have:
14522 # server: normal interpreter and a tiered C1/C2 compiler
14523 # client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14524 # minimal1: reduced form of client with optional VM services and features stripped out
14525 # kernel: kernel footprint JVM that passes the TCK without major performance problems,
14526 # ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14527 # zero: no machine code interpreter, no compiler
14528 # zeroshark: zero interpreter and shark/llvm compiler backend
14529 # core: interpreter only, no compiler (only works on some platforms)
14530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14531 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14532
14533 # Check whether --with-jvm-variants was given.
14534 if test "${with_jvm_variants+set}" = set; then :
14535 withval=$with_jvm_variants;
14536 fi
14537
14538
14539 if test "x$with_jvm_variants" = x; then
14540 with_jvm_variants="server"
14541 fi
14542
14543 JVM_VARIANTS=",$with_jvm_variants,"
14544 TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/minimal1,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//' -e 's/core,//'`
14545
14546 if test "x$TEST_VARIANTS" != "x,"; then
14547 as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14548 fi
14549 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14550 $as_echo "$with_jvm_variants" >&6; }
14551
14552 JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14553 JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14554 JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14555 JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14556 JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14557 JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14558 JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14559
14560 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14561 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14562 as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14563 fi
14564 fi
14565 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14566 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14567 as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14568 fi
14569 fi
14570 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14571 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14572 as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14573 fi
14574 fi
14575
14576 # Replace the commas with AND for use in the build directory name.
14577 ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14578 COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/minimal1,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/' -e 's/core,/1/'`
14579 if test "x$COUNT_VARIANTS" != "x,1"; then
14580 BUILDING_MULTIPLE_JVM_VARIANTS=yes
14581 else
14582 BUILDING_MULTIPLE_JVM_VARIANTS=no
14583 fi
14584
14585
14586
14587
14588
14589
14590
14591
14592
14593
14594 INCLUDE_SA=true
14595 if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14596 INCLUDE_SA=false
14597 fi
14598 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14599 INCLUDE_SA=false
14600 fi
14601 if test "x$OPENJDK_TARGET_OS" = xaix ; then
14602 INCLUDE_SA=false
14603 fi
14604 if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14605 INCLUDE_SA=false
14606 fi
14607
14608
14609 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14610 MACOSX_UNIVERSAL="true"
14611 fi
14612
14613
14614
14615
14616 ###############################################################################
14617 #
14618 # Set the debug level
14619 # release: no debug information, all optimizations, no asserts.
14620 # optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14621 # fastdebug: debug information (-g), all optimizations, all asserts
14622 # slowdebug: debug information (-g), no optimizations, all asserts
14623 #
14624 DEBUG_LEVEL="release"
14625 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14626 $as_echo_n "checking which debug level to use... " >&6; }
14627 # Check whether --enable-debug was given.
14628 if test "${enable_debug+set}" = set; then :
14629 enableval=$enable_debug;
14630 ENABLE_DEBUG="${enableval}"
14631 DEBUG_LEVEL="fastdebug"
14632
14633 else
14634 ENABLE_DEBUG="no"
14635 fi
14636
14637
14638
14639 # Check whether --with-debug-level was given.
14640 if test "${with_debug_level+set}" = set; then :
14641 withval=$with_debug_level;
14642 DEBUG_LEVEL="${withval}"
14643 if test "x$ENABLE_DEBUG" = xyes; then
14644 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14645 fi
14646
14647 fi
14648
14649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14650 $as_echo "$DEBUG_LEVEL" >&6; }
14651
14652 if test "x$DEBUG_LEVEL" != xrelease && \
14653 test "x$DEBUG_LEVEL" != xoptimized && \
14654 test "x$DEBUG_LEVEL" != xfastdebug && \
14655 test "x$DEBUG_LEVEL" != xslowdebug; then
14656 as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14657 fi
14658
14659
14660 ###############################################################################
14661 #
14662 # Setup legacy vars/targets and new vars to deal with different debug levels.
14663 #
14664
14665 case $DEBUG_LEVEL in
14666 release )
14667 VARIANT="OPT"
14668 FASTDEBUG="false"
14669 DEBUG_CLASSFILES="false"
14670 BUILD_VARIANT_RELEASE=""
14671 HOTSPOT_DEBUG_LEVEL="product"
14672 HOTSPOT_EXPORT="product"
14673 ;;
14674 fastdebug )
14675 VARIANT="DBG"
14676 FASTDEBUG="true"
14677 DEBUG_CLASSFILES="true"
14678 BUILD_VARIANT_RELEASE="-fastdebug"
14679 HOTSPOT_DEBUG_LEVEL="fastdebug"
14680 HOTSPOT_EXPORT="fastdebug"
14681 ;;
14682 slowdebug )
14683 VARIANT="DBG"
14684 FASTDEBUG="false"
14685 DEBUG_CLASSFILES="true"
14686 BUILD_VARIANT_RELEASE="-debug"
14687 HOTSPOT_DEBUG_LEVEL="debug"
14688 HOTSPOT_EXPORT="debug"
14689 ;;
14690 optimized )
14691 VARIANT="OPT"
14692 FASTDEBUG="false"
14693 DEBUG_CLASSFILES="false"
14694 BUILD_VARIANT_RELEASE="-optimized"
14695 HOTSPOT_DEBUG_LEVEL="optimized"
14696 HOTSPOT_EXPORT="optimized"
14697 ;;
14698 esac
14699
14700 # The debug level 'optimized' is a little special because it is currently only
14701 # applicable to the HotSpot build where it means to build a completely
14702 # optimized version of the VM without any debugging code (like for the
14703 # 'release' debug level which is called 'product' in the HotSpot build) but
14704 # with the exception that it can contain additional code which is otherwise
14705 # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14706 # test new and/or experimental features which are not intended for customer
14707 # shipment. Because these new features need to be tested and benchmarked in
14708 # real world scenarios, we want to build the containing JDK at the 'release'
14709 # debug level.
14710 if test "x$DEBUG_LEVEL" = xoptimized; then
14711 DEBUG_LEVEL="release"
14712 fi
14713
14714 #####
14715 # Generate the legacy makefile targets for hotspot.
14716 # The hotspot api for selecting the build artifacts, really, needs to be improved.
14717 # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14718 # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14719 # But until then ...
14720 HOTSPOT_TARGET=""
14721
14722 if test "x$JVM_VARIANT_SERVER" = xtrue; then
14723 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14724 fi
14725
14726 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14727 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14728 fi
14729
14730 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14731 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14732 fi
14733
14734 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14735 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14736 fi
14737
14738 if test "x$JVM_VARIANT_ZERO" = xtrue; then
14739 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14740 fi
14741
14742 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14743 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14744 fi
14745
14746 if test "x$JVM_VARIANT_CORE" = xtrue; then
14747 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14748 fi
14749
14750 HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14751
14752 # On Macosx universal binaries are produced, but they only contain
14753 # 64 bit intel. This invalidates control of which jvms are built
14754 # from configure, but only server is valid anyway. Fix this
14755 # when hotspot makefiles are rewritten.
14756 if test "x$MACOSX_UNIVERSAL" = xtrue; then
14757 HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14758 fi
14759
14760 #####
14761
14762
14763
14764
14765
14766
14767
14768
14769 # With basic setup done, call the custom early hook.
14770
14771
14772 # Check if we have devkits, extra paths or sysroot set.
14773
14774
14775 # Check whether --with-devkit was given.
14776 if test "${with_devkit+set}" = set; then :
14777 withval=$with_devkit;
14778
14779 # Only process if variable expands to non-empty
14780
14781 if test "x$with_devkit" != x; then
14782 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14783
14784 # Input might be given as Windows format, start by converting to
14785 # unix format.
14786 path="$with_devkit"
14787 new_path=`$CYGPATH -u "$path"`
14788
14789 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14790 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14791 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14792 # "foo.exe" is OK but "foo" is an error.
14793 #
14794 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14795 # It is also a way to make sure we got the proper file name for the real test later on.
14796 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14797 if test "x$test_shortpath" = x; then
14798 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14799 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14800 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14801 fi
14802
14803 # Call helper function which possibly converts this using DOS-style short mode.
14804 # If so, the updated path is stored in $new_path.
14805
14806 input_path="$new_path"
14807 # Check if we need to convert this using DOS-style short mode. If the path
14808 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14809 # take no chances and rewrite it.
14810 # Note: m4 eats our [], so we need to use [ and ] instead.
14811 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14812 if test "x$has_forbidden_chars" != x; then
14813 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14814 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14815 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14816 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14817 # Going to short mode and back again did indeed matter. Since short mode is
14818 # case insensitive, let's make it lowercase to improve readability.
14819 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14820 # Now convert it back to Unix-stile (cygpath)
14821 input_path=`$CYGPATH -u "$shortmode_path"`
14822 new_path="$input_path"
14823 fi
14824 fi
14825
14826 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14827 if test "x$test_cygdrive_prefix" = x; then
14828 # As a simple fix, exclude /usr/bin since it's not a real path.
14829 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14830 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14831 # a path prefixed by /cygdrive for fixpath to work.
14832 new_path="$CYGWIN_ROOT_PATH$input_path"
14833 fi
14834 fi
14835
14836
14837 if test "x$path" != "x$new_path"; then
14838 with_devkit="$new_path"
14839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14840 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14841 fi
14842
14843 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14844
14845 path="$with_devkit"
14846 has_colon=`$ECHO $path | $GREP ^.:`
14847 new_path="$path"
14848 if test "x$has_colon" = x; then
14849 # Not in mixed or Windows style, start by that.
14850 new_path=`cmd //c echo $path`
14851 fi
14852
14853
14854 input_path="$new_path"
14855 # Check if we need to convert this using DOS-style short mode. If the path
14856 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14857 # take no chances and rewrite it.
14858 # Note: m4 eats our [], so we need to use [ and ] instead.
14859 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14860 if test "x$has_forbidden_chars" != x; then
14861 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14862 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14863 fi
14864
14865
14866 windows_path="$new_path"
14867 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14868 unix_path=`$CYGPATH -u "$windows_path"`
14869 new_path="$unix_path"
14870 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14871 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14872 new_path="$unix_path"
14873 fi
14874
14875 if test "x$path" != "x$new_path"; then
14876 with_devkit="$new_path"
14877 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14878 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14879 fi
14880
14881 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14882 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14883
14884 else
14885 # We're on a unix platform. Hooray! :)
14886 path="$with_devkit"
14887 has_space=`$ECHO "$path" | $GREP " "`
14888 if test "x$has_space" != x; then
14889 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14890 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14891 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14892 fi
14893
14894 # Use eval to expand a potential ~
14895 eval path="$path"
14896 if test ! -f "$path" && test ! -d "$path"; then
14897 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14898 fi
14899
14900 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14901 fi
14902 fi
14903
14904 DEVKIT_ROOT="$with_devkit"
14905 # Check for a meta data info file in the root of the devkit
14906 if test -f "$DEVKIT_ROOT/devkit.info"; then
14907 # This potentially sets the following:
14908 # DEVKIT_NAME: A descriptive name of the devkit
14909 # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
14910 # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
14911 # DEVKIT_SYSROOT: Corresponds to --with-sysroot
14912 . $DEVKIT_ROOT/devkit.info
14913 fi
14914
14915 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14916 $as_echo_n "checking for devkit... " >&6; }
14917 if test "x$DEVKIT_NAME" != x; then
14918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14919 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14920 else
14921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14922 $as_echo "$DEVKIT_ROOT" >&6; }
14923 fi
14924
14925 if test "x$DEVKIT_EXTRA_PATH" != x; then
14926
14927 if test "x$DEVKIT_EXTRA_PATH" != x; then
14928 if test "x$EXTRA_PATH" = x; then
14929 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14930 else
14931 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14932 fi
14933 fi
14934
14935 fi
14936
14937 # Fallback default of just /bin if DEVKIT_PATH is not defined
14938 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14939 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14940 fi
14941
14942 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14943 if test "x$TOOLCHAIN_PATH" = x; then
14944 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14945 else
14946 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14947 fi
14948 fi
14949
14950
14951 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14952 # places for backwards compatiblity.
14953 if test "x$DEVKIT_SYSROOT" != x; then
14954 SYSROOT="$DEVKIT_SYSROOT"
14955 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
14956 SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
14957 elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
14958 SYSROOT="$DEVKIT_ROOT/$host/sys-root"
14959 fi
14960
14961
14962 fi
14963
14964
14965 # You can force the sysroot if the sysroot encoded into the compiler tools
14966 # is not correct.
14967
14968 # Check whether --with-sys-root was given.
14969 if test "${with_sys_root+set}" = set; then :
14970 withval=$with_sys_root; SYSROOT=$with_sys_root
14971
14972 fi
14973
14974
14975
14976 # Check whether --with-sysroot was given.
14977 if test "${with_sysroot+set}" = set; then :
14978 withval=$with_sysroot; SYSROOT=$with_sysroot
14979
14980 fi
14981
14982
14983
14984 # Check whether --with-tools-dir was given.
14985 if test "${with_tools_dir+set}" = set; then :
14986 withval=$with_tools_dir;
14987 if test "x$with_tools_dir" != x; then
14988 if test "x$TOOLCHAIN_PATH" = x; then
14989 TOOLCHAIN_PATH="$with_tools_dir"
14990 else
14991 TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
14992 fi
14993 fi
14994
14995
14996 fi
14997
14998
14999
15000 # Check whether --with-toolchain-path was given.
15001 if test "${with_toolchain_path+set}" = set; then :
15002 withval=$with_toolchain_path;
15003 if test "x$with_toolchain_path" != x; then
15004 if test "x$TOOLCHAIN_PATH" = x; then
15005 TOOLCHAIN_PATH="$with_toolchain_path"
15006 else
15007 TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15008 fi
15009 fi
15010
15011
15012 fi
15013
15014
15015
15016 # Check whether --with-extra-path was given.
15017 if test "${with_extra_path+set}" = set; then :
15018 withval=$with_extra_path;
15019 if test "x$with_extra_path" != x; then
15020 if test "x$EXTRA_PATH" = x; then
15021 EXTRA_PATH="$with_extra_path"
15022 else
15023 EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15024 fi
15025 fi
15026
15027
15028 fi
15029
15030
15031 if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
15032 # detect if Xcode is installed by running xcodebuild -version
15033 # if no Xcode installed, xcodebuild exits with 1
15034 # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
15035 if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
15036 # We need to use xcodebuild in the toolchain dir provided by the user, this will
15037 # fall back on the stub binary in /usr/bin/xcodebuild
15038 # Extract the first word of "xcodebuild", so it can be a program name with args.
15039 set dummy xcodebuild; ac_word=$2
15040 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15041 $as_echo_n "checking for $ac_word... " >&6; }
15042 if ${ac_cv_path_XCODEBUILD+:} false; then :
15043 $as_echo_n "(cached) " >&6
15044 else
15045 case $XCODEBUILD in
15046 [\\/]* | ?:[\\/]*)
15047 ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
15048 ;;
15049 *)
15050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15051 for as_dir in $TOOLCHAIN_PATH
15052 do
15053 IFS=$as_save_IFS
15054 test -z "$as_dir" && as_dir=.
15055 for ac_exec_ext in '' $ac_executable_extensions; do
15056 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15057 ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
15058 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15059 break 2
15060 fi
15061 done
15062 done
15063 IFS=$as_save_IFS
15064
15065 test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
15066 ;;
15067 esac
15068 fi
15069 XCODEBUILD=$ac_cv_path_XCODEBUILD
15070 if test -n "$XCODEBUILD"; then
15071 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
15072 $as_echo "$XCODEBUILD" >&6; }
15073 else
15074 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15075 $as_echo "no" >&6; }
15076 fi
15077
15078
15079 else
15080 # this should result in SYSROOT being empty, unless --with-sysroot is provided
15081 # when only the command line tools are installed there are no SDKs, so headers
15082 # are copied into the system frameworks
15083 XCODEBUILD=
15084
15085 fi
15086
15087 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
15088 $as_echo_n "checking for sdk name... " >&6; }
15089
15090 # Check whether --with-sdk-name was given.
15091 if test "${with_sdk_name+set}" = set; then :
15092 withval=$with_sdk_name; SDKNAME=$with_sdk_name
15093
15094 fi
15095
15096 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
15097 $as_echo "$SDKNAME" >&6; }
15098
15099 # if toolchain path is specified then don't rely on system headers, they may not compile
15100 HAVE_SYSTEM_FRAMEWORK_HEADERS=0
15101 test -z "$TOOLCHAIN_PATH" && \
15102 HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
15103
15104 if test -z "$SYSROOT"; then
15105 if test -n "$XCODEBUILD"; then
15106 # if we don't have system headers, use default SDK name (last resort)
15107 if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15108 SDKNAME=${SDKNAME:-macosx}
15109 fi
15110
15111 if test -n "$SDKNAME"; then
15112 # Call xcodebuild to determine SYSROOT
15113 SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
15114 fi
15115 else
15116 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15117 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
15118 fi
15119 fi
15120 else
15121 # warn user if --with-sdk-name was also set
15122 if test -n "$with_sdk_name"; then
15123 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
15124 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
15125 fi
15126 fi
15127
15128 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
15129 # If no system framework headers, then SYSROOT must be set, or we won't build
15130 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
15131 fi
15132
15133 # Perform a basic sanity test
15134 if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
15135 if test -z "$SYSROOT"; then
15136 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
15137 else
15138 as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
15139 fi
15140 fi
15141
15142 # set SDKROOT too, Xcode tools will pick it up
15143 SDKROOT=$SYSROOT
15144
15145 fi
15146
15147 # Prepend the extra path to the global path
15148
15149 if test "x$EXTRA_PATH" != x; then
15150 if test "x$PATH" = x; then
15151 PATH="$EXTRA_PATH"
15152 else
15153 PATH="$EXTRA_PATH:$PATH"
15154 fi
15155 fi
15156
15157
15158 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15159 # Add extra search paths on solaris for utilities like ar and as etc...
15160 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15161 fi
15162
15163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15164 $as_echo_n "checking for sysroot... " >&6; }
15165 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15166 $as_echo "$SYSROOT" >&6; }
15167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15168 $as_echo_n "checking for toolchain path... " >&6; }
15169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15170 $as_echo "$TOOLCHAIN_PATH" >&6; }
15171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15172 $as_echo_n "checking for extra path... " >&6; }
15173 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15174 $as_echo "$EXTRA_PATH" >&6; }
15175
15176
15177 # To properly create a configuration name, we need to have the OpenJDK target
15178 # and options (variants and debug level) parsed.
15179
15180
15181
15182 # Check whether --with-conf-name was given.
15183 if test "${with_conf_name+set}" = set; then :
15184 withval=$with_conf_name; CONF_NAME=${with_conf_name}
15185 fi
15186
15187
15188 # Test from where we are running configure, in or outside of src root.
15189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15190 $as_echo_n "checking where to store configuration... " >&6; }
15191 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15192 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15193 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15194 # We are running configure from the src root.
15195 # Create a default ./build/target-variant-debuglevel output root.
15196 if test "x${CONF_NAME}" = x; then
15197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15198 $as_echo "in default location" >&6; }
15199 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15200 else
15201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15202 $as_echo "in build directory with custom name" >&6; }
15203 fi
15204 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15205 $MKDIR -p "$OUTPUT_ROOT"
15206 if test ! -d "$OUTPUT_ROOT"; then
15207 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15208 fi
15209 else
15210 # We are running configure from outside of the src dir.
15211 # Then use the current directory as output dir!
15212 # If configuration is situated in normal build directory, just use the build
15213 # directory name as configuration name, otherwise use the complete path.
15214 if test "x${CONF_NAME}" = x; then
15215 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15216 fi
15217 OUTPUT_ROOT="$CURDIR"
15218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15219 $as_echo "in current directory" >&6; }
15220
15221 # WARNING: This might be a bad thing to do. You need to be sure you want to
15222 # have a configuration in this directory. Do some sanity checks!
15223
15224 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15225 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15226 # other files
15227 files_present=`$LS $OUTPUT_ROOT`
15228 # Configure has already touched config.log and confdefs.h in the current dir when this check
15229 # is performed.
15230 filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
15231 | $TR -d '\n'`
15232 if test "x$filtered_files" != x; then
15233 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15234 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15235 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15236 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15237 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15238 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15239 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15240 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15241 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15242 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15243 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15244 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15245 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15246 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15247 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15248 fi
15249 fi
15250 fi
15251 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15252 $as_echo_n "checking what configuration name to use... " >&6; }
15253 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15254 $as_echo "$CONF_NAME" >&6; }
15255
15256
15257 # Only process if variable expands to non-empty
15258
15259 if test "x$OUTPUT_ROOT" != x; then
15260 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15261
15262 # Input might be given as Windows format, start by converting to
15263 # unix format.
15264 path="$OUTPUT_ROOT"
15265 new_path=`$CYGPATH -u "$path"`
15266
15267 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15268 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15269 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15270 # "foo.exe" is OK but "foo" is an error.
15271 #
15272 # This test is therefore slightly more accurate than "test -f" to check for file precense.
15273 # It is also a way to make sure we got the proper file name for the real test later on.
15274 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15275 if test "x$test_shortpath" = x; then
15276 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15277 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15278 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15279 fi
15280
15281 # Call helper function which possibly converts this using DOS-style short mode.
15282 # If so, the updated path is stored in $new_path.
15283
15284 input_path="$new_path"
15285 # Check if we need to convert this using DOS-style short mode. If the path
15286 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15287 # take no chances and rewrite it.
15288 # Note: m4 eats our [], so we need to use [ and ] instead.
15289 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15290 if test "x$has_forbidden_chars" != x; then
15291 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15292 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15293 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15294 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15295 # Going to short mode and back again did indeed matter. Since short mode is
15296 # case insensitive, let's make it lowercase to improve readability.
15297 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15298 # Now convert it back to Unix-stile (cygpath)
15299 input_path=`$CYGPATH -u "$shortmode_path"`
15300 new_path="$input_path"
15301 fi
15302 fi
15303
15304 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15305 if test "x$test_cygdrive_prefix" = x; then
15306 # As a simple fix, exclude /usr/bin since it's not a real path.
15307 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15308 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15309 # a path prefixed by /cygdrive for fixpath to work.
15310 new_path="$CYGWIN_ROOT_PATH$input_path"
15311 fi
15312 fi
15313
15314
15315 if test "x$path" != "x$new_path"; then
15316 OUTPUT_ROOT="$new_path"
15317 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15318 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15319 fi
15320
15321 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15322
15323 path="$OUTPUT_ROOT"
15324 has_colon=`$ECHO $path | $GREP ^.:`
15325 new_path="$path"
15326 if test "x$has_colon" = x; then
15327 # Not in mixed or Windows style, start by that.
15328 new_path=`cmd //c echo $path`
15329 fi
15330
15331
15332 input_path="$new_path"
15333 # Check if we need to convert this using DOS-style short mode. If the path
15334 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15335 # take no chances and rewrite it.
15336 # Note: m4 eats our [], so we need to use [ and ] instead.
15337 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15338 if test "x$has_forbidden_chars" != x; then
15339 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15340 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15341 fi
15342
15343
15344 windows_path="$new_path"
15345 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15346 unix_path=`$CYGPATH -u "$windows_path"`
15347 new_path="$unix_path"
15348 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15349 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15350 new_path="$unix_path"
15351 fi
15352
15353 if test "x$path" != "x$new_path"; then
15354 OUTPUT_ROOT="$new_path"
15355 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15356 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15357 fi
15358
15359 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15360 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15361
15362 else
15363 # We're on a unix platform. Hooray! :)
15364 path="$OUTPUT_ROOT"
15365 has_space=`$ECHO "$path" | $GREP " "`
15366 if test "x$has_space" != x; then
15367 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15368 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15369 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15370 fi
15371
15372 # Use eval to expand a potential ~
15373 eval path="$path"
15374 if test ! -f "$path" && test ! -d "$path"; then
15375 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15376 fi
15377
15378 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15379 fi
15380 fi
15381
15382
15383 SPEC=$OUTPUT_ROOT/spec.gmk
15384
15385 CONF_NAME=$CONF_NAME
15386
15387 OUTPUT_ROOT=$OUTPUT_ROOT
15388
15389
15390 # The spec.gmk file contains all variables for the make system.
15391 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15392
15393 # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15394 ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15395
15396 # The bootcycle-spec.gmk file contains support for boot cycle builds.
15397 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15398
15399 # The compare.sh is used to compare the build output to other builds.
15400 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15401
15402 # The generated Makefile knows where the spec.gmk is and where the source is.
15403 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15404 # which will look for generated configurations
15405 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15406
15407
15408
15409 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15410
15411 for ac_prog in apt-get yum port pkgutil pkgadd
15412 do
15413 # Extract the first word of "$ac_prog", so it can be a program name with args.
15414 set dummy $ac_prog; ac_word=$2
15415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15416 $as_echo_n "checking for $ac_word... " >&6; }
15417 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15418 $as_echo_n "(cached) " >&6
15419 else
15420 if test -n "$PKGHANDLER"; then
15421 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15422 else
15423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15424 for as_dir in $PATH
15425 do
15426 IFS=$as_save_IFS
15427 test -z "$as_dir" && as_dir=.
15428 for ac_exec_ext in '' $ac_executable_extensions; do
15429 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15430 ac_cv_prog_PKGHANDLER="$ac_prog"
15431 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15432 break 2
15433 fi
15434 done
15435 done
15436 IFS=$as_save_IFS
15437
15438 fi
15439 fi
15440 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15441 if test -n "$PKGHANDLER"; then
15442 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15443 $as_echo "$PKGHANDLER" >&6; }
15444 else
15445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15446 $as_echo "no" >&6; }
15447 fi
15448
15449
15450 test -n "$PKGHANDLER" && break
15451 done
15452
15453
15454
15455 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15456
15457
15458 # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15459 if test "x$MAKE" != x; then
15460 # User has supplied a make, test it.
15461 if test ! -f "$MAKE"; then
15462 as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15463 fi
15464
15465 MAKE_CANDIDATE=""$MAKE""
15466 DESCRIPTION="user supplied MAKE=$MAKE"
15467 if test "x$MAKE_CANDIDATE" != x; then
15468 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15469 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15470 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15471 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15472 if test "x$IS_GNU_MAKE" = x; then
15473 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15474 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15475 else
15476 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15477 if test "x$IS_MODERN_MAKE" = x; then
15478 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15479 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15480 else
15481 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15482 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15483 MAKE_EXPECTED_ENV='cygwin'
15484 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15485 MAKE_EXPECTED_ENV='msys'
15486 else
15487 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15488 fi
15489 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15490 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15491 else
15492 # Not relevant for non-Windows
15493 IS_MAKE_CORRECT_ENV=true
15494 fi
15495 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15496 { $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
15497 $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;}
15498 else
15499 FOUND_MAKE=$MAKE_CANDIDATE
15500
15501 # Only process if variable expands to non-empty
15502
15503 if test "x$FOUND_MAKE" != x; then
15504 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15505
15506 # First separate the path from the arguments. This will split at the first
15507 # space.
15508 complete="$FOUND_MAKE"
15509 path="${complete%% *}"
15510 tmp="$complete EOL"
15511 arguments="${tmp#* }"
15512
15513 # Input might be given as Windows format, start by converting to
15514 # unix format.
15515 new_path=`$CYGPATH -u "$path"`
15516
15517 # Now try to locate executable using which
15518 new_path=`$WHICH "$new_path" 2> /dev/null`
15519 # bat and cmd files are not always considered executable in cygwin causing which
15520 # to not find them
15521 if test "x$new_path" = x \
15522 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15523 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15524 new_path=`$CYGPATH -u "$path"`
15525 fi
15526 if test "x$new_path" = x; then
15527 # Oops. Which didn't find the executable.
15528 # The splitting of arguments from the executable at a space might have been incorrect,
15529 # since paths with space are more likely in Windows. Give it another try with the whole
15530 # argument.
15531 path="$complete"
15532 arguments="EOL"
15533 new_path=`$CYGPATH -u "$path"`
15534 new_path=`$WHICH "$new_path" 2> /dev/null`
15535 # bat and cmd files are not always considered executable in cygwin causing which
15536 # to not find them
15537 if test "x$new_path" = x \
15538 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15539 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15540 new_path=`$CYGPATH -u "$path"`
15541 fi
15542 if test "x$new_path" = x; then
15543 # It's still not found. Now this is an unrecoverable error.
15544 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15545 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15546 has_space=`$ECHO "$complete" | $GREP " "`
15547 if test "x$has_space" != x; then
15548 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15549 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15550 fi
15551 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15552 fi
15553 fi
15554
15555 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15556 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15557 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15558 # "foo.exe" is OK but "foo" is an error.
15559 #
15560 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15561 # It is also a way to make sure we got the proper file name for the real test later on.
15562 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15563 if test "x$test_shortpath" = x; then
15564 # Short path failed, file does not exist as specified.
15565 # Try adding .exe or .cmd
15566 if test -f "${new_path}.exe"; then
15567 input_to_shortpath="${new_path}.exe"
15568 elif test -f "${new_path}.cmd"; then
15569 input_to_shortpath="${new_path}.cmd"
15570 else
15571 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15572 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15573 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15574 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15575 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15576 fi
15577 else
15578 input_to_shortpath="$new_path"
15579 fi
15580
15581 # Call helper function which possibly converts this using DOS-style short mode.
15582 # If so, the updated path is stored in $new_path.
15583 new_path="$input_to_shortpath"
15584
15585 input_path="$input_to_shortpath"
15586 # Check if we need to convert this using DOS-style short mode. If the path
15587 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15588 # take no chances and rewrite it.
15589 # Note: m4 eats our [], so we need to use [ and ] instead.
15590 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15591 if test "x$has_forbidden_chars" != x; then
15592 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15593 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15594 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15595 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15596 # Going to short mode and back again did indeed matter. Since short mode is
15597 # case insensitive, let's make it lowercase to improve readability.
15598 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15599 # Now convert it back to Unix-stile (cygpath)
15600 input_path=`$CYGPATH -u "$shortmode_path"`
15601 new_path="$input_path"
15602 fi
15603 fi
15604
15605 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15606 if test "x$test_cygdrive_prefix" = x; then
15607 # As a simple fix, exclude /usr/bin since it's not a real path.
15608 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15609 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15610 # a path prefixed by /cygdrive for fixpath to work.
15611 new_path="$CYGWIN_ROOT_PATH$input_path"
15612 fi
15613 fi
15614
15615 # remove trailing .exe if any
15616 new_path="${new_path/%.exe/}"
15617
15618 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15619
15620 # First separate the path from the arguments. This will split at the first
15621 # space.
15622 complete="$FOUND_MAKE"
15623 path="${complete%% *}"
15624 tmp="$complete EOL"
15625 arguments="${tmp#* }"
15626
15627 # Input might be given as Windows format, start by converting to
15628 # unix format.
15629 new_path="$path"
15630
15631 windows_path="$new_path"
15632 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15633 unix_path=`$CYGPATH -u "$windows_path"`
15634 new_path="$unix_path"
15635 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15636 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15637 new_path="$unix_path"
15638 fi
15639
15640
15641 # Now try to locate executable using which
15642 new_path=`$WHICH "$new_path" 2> /dev/null`
15643
15644 if test "x$new_path" = x; then
15645 # Oops. Which didn't find the executable.
15646 # The splitting of arguments from the executable at a space might have been incorrect,
15647 # since paths with space are more likely in Windows. Give it another try with the whole
15648 # argument.
15649 path="$complete"
15650 arguments="EOL"
15651 new_path="$path"
15652
15653 windows_path="$new_path"
15654 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15655 unix_path=`$CYGPATH -u "$windows_path"`
15656 new_path="$unix_path"
15657 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15658 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15659 new_path="$unix_path"
15660 fi
15661
15662
15663 new_path=`$WHICH "$new_path" 2> /dev/null`
15664 # bat and cmd files are not always considered executable in MSYS causing which
15665 # to not find them
15666 if test "x$new_path" = x \
15667 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15668 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15669 new_path="$path"
15670
15671 windows_path="$new_path"
15672 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15673 unix_path=`$CYGPATH -u "$windows_path"`
15674 new_path="$unix_path"
15675 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15676 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15677 new_path="$unix_path"
15678 fi
15679
15680 fi
15681
15682 if test "x$new_path" = x; then
15683 # It's still not found. Now this is an unrecoverable error.
15684 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15685 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15686 has_space=`$ECHO "$complete" | $GREP " "`
15687 if test "x$has_space" != x; then
15688 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15689 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15690 fi
15691 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15692 fi
15693 fi
15694
15695 # Now new_path has a complete unix path to the binary
15696 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15697 # Keep paths in /bin as-is, but remove trailing .exe if any
15698 new_path="${new_path/%.exe/}"
15699 # Do not save /bin paths to all_fixpath_prefixes!
15700 else
15701 # Not in mixed or Windows style, start by that.
15702 new_path=`cmd //c echo $new_path`
15703
15704 input_path="$new_path"
15705 # Check if we need to convert this using DOS-style short mode. If the path
15706 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15707 # take no chances and rewrite it.
15708 # Note: m4 eats our [], so we need to use [ and ] instead.
15709 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15710 if test "x$has_forbidden_chars" != x; then
15711 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15712 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15713 fi
15714
15715 # Output is in $new_path
15716
15717 windows_path="$new_path"
15718 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15719 unix_path=`$CYGPATH -u "$windows_path"`
15720 new_path="$unix_path"
15721 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15722 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15723 new_path="$unix_path"
15724 fi
15725
15726 # remove trailing .exe if any
15727 new_path="${new_path/%.exe/}"
15728
15729 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15730 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15731 fi
15732
15733 else
15734 # We're on a unix platform. Hooray! :)
15735 # First separate the path from the arguments. This will split at the first
15736 # space.
15737 complete="$FOUND_MAKE"
15738 path="${complete%% *}"
15739 tmp="$complete EOL"
15740 arguments="${tmp#* }"
15741
15742 # Cannot rely on the command "which" here since it doesn't always work.
15743 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15744 if test -z "$is_absolute_path"; then
15745 # Path to executable is not absolute. Find it.
15746 IFS_save="$IFS"
15747 IFS=:
15748 for p in $PATH; do
15749 if test -f "$p/$path" && test -x "$p/$path"; then
15750 new_path="$p/$path"
15751 break
15752 fi
15753 done
15754 IFS="$IFS_save"
15755 else
15756 # This is an absolute path, we can use it without further modifications.
15757 new_path="$path"
15758 fi
15759
15760 if test "x$new_path" = x; then
15761 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15762 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15763 has_space=`$ECHO "$complete" | $GREP " "`
15764 if test "x$has_space" != x; then
15765 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15766 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15767 fi
15768 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15769 fi
15770 fi
15771
15772 # Now join together the path and the arguments once again
15773 if test "x$arguments" != xEOL; then
15774 new_complete="$new_path ${arguments% *}"
15775 else
15776 new_complete="$new_path"
15777 fi
15778
15779 if test "x$complete" != "x$new_complete"; then
15780 FOUND_MAKE="$new_complete"
15781 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15782 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15783 fi
15784 fi
15785
15786 fi
15787 fi
15788 fi
15789 fi
15790
15791 if test "x$FOUND_MAKE" = x; then
15792 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15793 fi
15794 else
15795 # Try our hardest to locate a correct version of GNU make
15796 for ac_prog in gmake
15797 do
15798 # Extract the first word of "$ac_prog", so it can be a program name with args.
15799 set dummy $ac_prog; ac_word=$2
15800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15801 $as_echo_n "checking for $ac_word... " >&6; }
15802 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15803 $as_echo_n "(cached) " >&6
15804 else
15805 case $CHECK_GMAKE in
15806 [\\/]* | ?:[\\/]*)
15807 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15808 ;;
15809 *)
15810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15811 for as_dir in $PATH
15812 do
15813 IFS=$as_save_IFS
15814 test -z "$as_dir" && as_dir=.
15815 for ac_exec_ext in '' $ac_executable_extensions; do
15816 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15817 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15818 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15819 break 2
15820 fi
15821 done
15822 done
15823 IFS=$as_save_IFS
15824
15825 ;;
15826 esac
15827 fi
15828 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15829 if test -n "$CHECK_GMAKE"; then
15830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15831 $as_echo "$CHECK_GMAKE" >&6; }
15832 else
15833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15834 $as_echo "no" >&6; }
15835 fi
15836
15837
15838 test -n "$CHECK_GMAKE" && break
15839 done
15840
15841
15842 MAKE_CANDIDATE=""$CHECK_GMAKE""
15843 DESCRIPTION="gmake in PATH"
15844 if test "x$MAKE_CANDIDATE" != x; then
15845 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15846 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15847 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15848 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15849 if test "x$IS_GNU_MAKE" = x; then
15850 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15851 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15852 else
15853 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15854 if test "x$IS_MODERN_MAKE" = x; then
15855 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15856 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15857 else
15858 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15859 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15860 MAKE_EXPECTED_ENV='cygwin'
15861 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15862 MAKE_EXPECTED_ENV='msys'
15863 else
15864 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15865 fi
15866 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15867 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15868 else
15869 # Not relevant for non-Windows
15870 IS_MAKE_CORRECT_ENV=true
15871 fi
15872 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15873 { $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
15874 $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;}
15875 else
15876 FOUND_MAKE=$MAKE_CANDIDATE
15877
15878 # Only process if variable expands to non-empty
15879
15880 if test "x$FOUND_MAKE" != x; then
15881 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15882
15883 # First separate the path from the arguments. This will split at the first
15884 # space.
15885 complete="$FOUND_MAKE"
15886 path="${complete%% *}"
15887 tmp="$complete EOL"
15888 arguments="${tmp#* }"
15889
15890 # Input might be given as Windows format, start by converting to
15891 # unix format.
15892 new_path=`$CYGPATH -u "$path"`
15893
15894 # Now try to locate executable using which
15895 new_path=`$WHICH "$new_path" 2> /dev/null`
15896 # bat and cmd files are not always considered executable in cygwin causing which
15897 # to not find them
15898 if test "x$new_path" = x \
15899 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15900 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15901 new_path=`$CYGPATH -u "$path"`
15902 fi
15903 if test "x$new_path" = x; then
15904 # Oops. Which didn't find the executable.
15905 # The splitting of arguments from the executable at a space might have been incorrect,
15906 # since paths with space are more likely in Windows. Give it another try with the whole
15907 # argument.
15908 path="$complete"
15909 arguments="EOL"
15910 new_path=`$CYGPATH -u "$path"`
15911 new_path=`$WHICH "$new_path" 2> /dev/null`
15912 # bat and cmd files are not always considered executable in cygwin causing which
15913 # to not find them
15914 if test "x$new_path" = x \
15915 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15916 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15917 new_path=`$CYGPATH -u "$path"`
15918 fi
15919 if test "x$new_path" = x; then
15920 # It's still not found. Now this is an unrecoverable error.
15921 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15922 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15923 has_space=`$ECHO "$complete" | $GREP " "`
15924 if test "x$has_space" != x; then
15925 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15926 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15927 fi
15928 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15929 fi
15930 fi
15931
15932 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15933 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15934 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15935 # "foo.exe" is OK but "foo" is an error.
15936 #
15937 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15938 # It is also a way to make sure we got the proper file name for the real test later on.
15939 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15940 if test "x$test_shortpath" = x; then
15941 # Short path failed, file does not exist as specified.
15942 # Try adding .exe or .cmd
15943 if test -f "${new_path}.exe"; then
15944 input_to_shortpath="${new_path}.exe"
15945 elif test -f "${new_path}.cmd"; then
15946 input_to_shortpath="${new_path}.cmd"
15947 else
15948 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15949 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15950 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15951 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15952 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15953 fi
15954 else
15955 input_to_shortpath="$new_path"
15956 fi
15957
15958 # Call helper function which possibly converts this using DOS-style short mode.
15959 # If so, the updated path is stored in $new_path.
15960 new_path="$input_to_shortpath"
15961
15962 input_path="$input_to_shortpath"
15963 # Check if we need to convert this using DOS-style short mode. If the path
15964 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15965 # take no chances and rewrite it.
15966 # Note: m4 eats our [], so we need to use [ and ] instead.
15967 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15968 if test "x$has_forbidden_chars" != x; then
15969 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15970 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15971 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15972 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15973 # Going to short mode and back again did indeed matter. Since short mode is
15974 # case insensitive, let's make it lowercase to improve readability.
15975 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15976 # Now convert it back to Unix-stile (cygpath)
15977 input_path=`$CYGPATH -u "$shortmode_path"`
15978 new_path="$input_path"
15979 fi
15980 fi
15981
15982 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15983 if test "x$test_cygdrive_prefix" = x; then
15984 # As a simple fix, exclude /usr/bin since it's not a real path.
15985 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15986 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15987 # a path prefixed by /cygdrive for fixpath to work.
15988 new_path="$CYGWIN_ROOT_PATH$input_path"
15989 fi
15990 fi
15991
15992 # remove trailing .exe if any
15993 new_path="${new_path/%.exe/}"
15994
15995 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15996
15997 # First separate the path from the arguments. This will split at the first
15998 # space.
15999 complete="$FOUND_MAKE"
16000 path="${complete%% *}"
16001 tmp="$complete EOL"
16002 arguments="${tmp#* }"
16003
16004 # Input might be given as Windows format, start by converting to
16005 # unix format.
16006 new_path="$path"
16007
16008 windows_path="$new_path"
16009 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16010 unix_path=`$CYGPATH -u "$windows_path"`
16011 new_path="$unix_path"
16012 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16013 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16014 new_path="$unix_path"
16015 fi
16016
16017
16018 # Now try to locate executable using which
16019 new_path=`$WHICH "$new_path" 2> /dev/null`
16020
16021 if test "x$new_path" = x; then
16022 # Oops. Which didn't find the executable.
16023 # The splitting of arguments from the executable at a space might have been incorrect,
16024 # since paths with space are more likely in Windows. Give it another try with the whole
16025 # argument.
16026 path="$complete"
16027 arguments="EOL"
16028 new_path="$path"
16029
16030 windows_path="$new_path"
16031 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16032 unix_path=`$CYGPATH -u "$windows_path"`
16033 new_path="$unix_path"
16034 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16035 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16036 new_path="$unix_path"
16037 fi
16038
16039
16040 new_path=`$WHICH "$new_path" 2> /dev/null`
16041 # bat and cmd files are not always considered executable in MSYS causing which
16042 # to not find them
16043 if test "x$new_path" = x \
16044 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16045 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16046 new_path="$path"
16047
16048 windows_path="$new_path"
16049 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16050 unix_path=`$CYGPATH -u "$windows_path"`
16051 new_path="$unix_path"
16052 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16053 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16054 new_path="$unix_path"
16055 fi
16056
16057 fi
16058
16059 if test "x$new_path" = x; then
16060 # It's still not found. Now this is an unrecoverable error.
16061 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16062 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16063 has_space=`$ECHO "$complete" | $GREP " "`
16064 if test "x$has_space" != x; then
16065 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16066 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16067 fi
16068 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16069 fi
16070 fi
16071
16072 # Now new_path has a complete unix path to the binary
16073 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16074 # Keep paths in /bin as-is, but remove trailing .exe if any
16075 new_path="${new_path/%.exe/}"
16076 # Do not save /bin paths to all_fixpath_prefixes!
16077 else
16078 # Not in mixed or Windows style, start by that.
16079 new_path=`cmd //c echo $new_path`
16080
16081 input_path="$new_path"
16082 # Check if we need to convert this using DOS-style short mode. If the path
16083 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16084 # take no chances and rewrite it.
16085 # Note: m4 eats our [], so we need to use [ and ] instead.
16086 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16087 if test "x$has_forbidden_chars" != x; then
16088 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16089 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16090 fi
16091
16092 # Output is in $new_path
16093
16094 windows_path="$new_path"
16095 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16096 unix_path=`$CYGPATH -u "$windows_path"`
16097 new_path="$unix_path"
16098 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16099 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16100 new_path="$unix_path"
16101 fi
16102
16103 # remove trailing .exe if any
16104 new_path="${new_path/%.exe/}"
16105
16106 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16107 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16108 fi
16109
16110 else
16111 # We're on a unix platform. Hooray! :)
16112 # First separate the path from the arguments. This will split at the first
16113 # space.
16114 complete="$FOUND_MAKE"
16115 path="${complete%% *}"
16116 tmp="$complete EOL"
16117 arguments="${tmp#* }"
16118
16119 # Cannot rely on the command "which" here since it doesn't always work.
16120 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16121 if test -z "$is_absolute_path"; then
16122 # Path to executable is not absolute. Find it.
16123 IFS_save="$IFS"
16124 IFS=:
16125 for p in $PATH; do
16126 if test -f "$p/$path" && test -x "$p/$path"; then
16127 new_path="$p/$path"
16128 break
16129 fi
16130 done
16131 IFS="$IFS_save"
16132 else
16133 # This is an absolute path, we can use it without further modifications.
16134 new_path="$path"
16135 fi
16136
16137 if test "x$new_path" = x; then
16138 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16139 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16140 has_space=`$ECHO "$complete" | $GREP " "`
16141 if test "x$has_space" != x; then
16142 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16143 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16144 fi
16145 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16146 fi
16147 fi
16148
16149 # Now join together the path and the arguments once again
16150 if test "x$arguments" != xEOL; then
16151 new_complete="$new_path ${arguments% *}"
16152 else
16153 new_complete="$new_path"
16154 fi
16155
16156 if test "x$complete" != "x$new_complete"; then
16157 FOUND_MAKE="$new_complete"
16158 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16159 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16160 fi
16161 fi
16162
16163 fi
16164 fi
16165 fi
16166 fi
16167
16168
16169 if test "x$FOUND_MAKE" = x; then
16170 for ac_prog in make
16171 do
16172 # Extract the first word of "$ac_prog", so it can be a program name with args.
16173 set dummy $ac_prog; ac_word=$2
16174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16175 $as_echo_n "checking for $ac_word... " >&6; }
16176 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16177 $as_echo_n "(cached) " >&6
16178 else
16179 case $CHECK_MAKE in
16180 [\\/]* | ?:[\\/]*)
16181 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16182 ;;
16183 *)
16184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16185 for as_dir in $PATH
16186 do
16187 IFS=$as_save_IFS
16188 test -z "$as_dir" && as_dir=.
16189 for ac_exec_ext in '' $ac_executable_extensions; do
16190 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16191 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16192 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16193 break 2
16194 fi
16195 done
16196 done
16197 IFS=$as_save_IFS
16198
16199 ;;
16200 esac
16201 fi
16202 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16203 if test -n "$CHECK_MAKE"; then
16204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16205 $as_echo "$CHECK_MAKE" >&6; }
16206 else
16207 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16208 $as_echo "no" >&6; }
16209 fi
16210
16211
16212 test -n "$CHECK_MAKE" && break
16213 done
16214
16215
16216 MAKE_CANDIDATE=""$CHECK_MAKE""
16217 DESCRIPTION="make in PATH"
16218 if test "x$MAKE_CANDIDATE" != x; then
16219 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16220 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16221 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16222 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16223 if test "x$IS_GNU_MAKE" = x; then
16224 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16225 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16226 else
16227 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16228 if test "x$IS_MODERN_MAKE" = x; then
16229 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16230 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16231 else
16232 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16233 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16234 MAKE_EXPECTED_ENV='cygwin'
16235 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16236 MAKE_EXPECTED_ENV='msys'
16237 else
16238 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16239 fi
16240 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16241 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16242 else
16243 # Not relevant for non-Windows
16244 IS_MAKE_CORRECT_ENV=true
16245 fi
16246 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16247 { $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
16248 $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;}
16249 else
16250 FOUND_MAKE=$MAKE_CANDIDATE
16251
16252 # Only process if variable expands to non-empty
16253
16254 if test "x$FOUND_MAKE" != x; then
16255 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16256
16257 # First separate the path from the arguments. This will split at the first
16258 # space.
16259 complete="$FOUND_MAKE"
16260 path="${complete%% *}"
16261 tmp="$complete EOL"
16262 arguments="${tmp#* }"
16263
16264 # Input might be given as Windows format, start by converting to
16265 # unix format.
16266 new_path=`$CYGPATH -u "$path"`
16267
16268 # Now try to locate executable using which
16269 new_path=`$WHICH "$new_path" 2> /dev/null`
16270 # bat and cmd files are not always considered executable in cygwin causing which
16271 # to not find them
16272 if test "x$new_path" = x \
16273 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16274 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16275 new_path=`$CYGPATH -u "$path"`
16276 fi
16277 if test "x$new_path" = x; then
16278 # Oops. Which didn't find the executable.
16279 # The splitting of arguments from the executable at a space might have been incorrect,
16280 # since paths with space are more likely in Windows. Give it another try with the whole
16281 # argument.
16282 path="$complete"
16283 arguments="EOL"
16284 new_path=`$CYGPATH -u "$path"`
16285 new_path=`$WHICH "$new_path" 2> /dev/null`
16286 # bat and cmd files are not always considered executable in cygwin causing which
16287 # to not find them
16288 if test "x$new_path" = x \
16289 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16290 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16291 new_path=`$CYGPATH -u "$path"`
16292 fi
16293 if test "x$new_path" = x; then
16294 # It's still not found. Now this is an unrecoverable error.
16295 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16296 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16297 has_space=`$ECHO "$complete" | $GREP " "`
16298 if test "x$has_space" != x; then
16299 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16300 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16301 fi
16302 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16303 fi
16304 fi
16305
16306 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16307 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16308 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16309 # "foo.exe" is OK but "foo" is an error.
16310 #
16311 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16312 # It is also a way to make sure we got the proper file name for the real test later on.
16313 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16314 if test "x$test_shortpath" = x; then
16315 # Short path failed, file does not exist as specified.
16316 # Try adding .exe or .cmd
16317 if test -f "${new_path}.exe"; then
16318 input_to_shortpath="${new_path}.exe"
16319 elif test -f "${new_path}.cmd"; then
16320 input_to_shortpath="${new_path}.cmd"
16321 else
16322 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16323 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16324 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16325 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16326 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16327 fi
16328 else
16329 input_to_shortpath="$new_path"
16330 fi
16331
16332 # Call helper function which possibly converts this using DOS-style short mode.
16333 # If so, the updated path is stored in $new_path.
16334 new_path="$input_to_shortpath"
16335
16336 input_path="$input_to_shortpath"
16337 # Check if we need to convert this using DOS-style short mode. If the path
16338 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16339 # take no chances and rewrite it.
16340 # Note: m4 eats our [], so we need to use [ and ] instead.
16341 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16342 if test "x$has_forbidden_chars" != x; then
16343 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16344 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16345 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16346 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16347 # Going to short mode and back again did indeed matter. Since short mode is
16348 # case insensitive, let's make it lowercase to improve readability.
16349 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16350 # Now convert it back to Unix-stile (cygpath)
16351 input_path=`$CYGPATH -u "$shortmode_path"`
16352 new_path="$input_path"
16353 fi
16354 fi
16355
16356 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16357 if test "x$test_cygdrive_prefix" = x; then
16358 # As a simple fix, exclude /usr/bin since it's not a real path.
16359 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16360 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16361 # a path prefixed by /cygdrive for fixpath to work.
16362 new_path="$CYGWIN_ROOT_PATH$input_path"
16363 fi
16364 fi
16365
16366 # remove trailing .exe if any
16367 new_path="${new_path/%.exe/}"
16368
16369 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16370
16371 # First separate the path from the arguments. This will split at the first
16372 # space.
16373 complete="$FOUND_MAKE"
16374 path="${complete%% *}"
16375 tmp="$complete EOL"
16376 arguments="${tmp#* }"
16377
16378 # Input might be given as Windows format, start by converting to
16379 # unix format.
16380 new_path="$path"
16381
16382 windows_path="$new_path"
16383 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16384 unix_path=`$CYGPATH -u "$windows_path"`
16385 new_path="$unix_path"
16386 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16387 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16388 new_path="$unix_path"
16389 fi
16390
16391
16392 # Now try to locate executable using which
16393 new_path=`$WHICH "$new_path" 2> /dev/null`
16394
16395 if test "x$new_path" = x; then
16396 # Oops. Which didn't find the executable.
16397 # The splitting of arguments from the executable at a space might have been incorrect,
16398 # since paths with space are more likely in Windows. Give it another try with the whole
16399 # argument.
16400 path="$complete"
16401 arguments="EOL"
16402 new_path="$path"
16403
16404 windows_path="$new_path"
16405 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16406 unix_path=`$CYGPATH -u "$windows_path"`
16407 new_path="$unix_path"
16408 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16409 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16410 new_path="$unix_path"
16411 fi
16412
16413
16414 new_path=`$WHICH "$new_path" 2> /dev/null`
16415 # bat and cmd files are not always considered executable in MSYS causing which
16416 # to not find them
16417 if test "x$new_path" = x \
16418 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16419 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16420 new_path="$path"
16421
16422 windows_path="$new_path"
16423 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16424 unix_path=`$CYGPATH -u "$windows_path"`
16425 new_path="$unix_path"
16426 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16427 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16428 new_path="$unix_path"
16429 fi
16430
16431 fi
16432
16433 if test "x$new_path" = x; then
16434 # It's still not found. Now this is an unrecoverable error.
16435 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16436 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16437 has_space=`$ECHO "$complete" | $GREP " "`
16438 if test "x$has_space" != x; then
16439 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16440 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16441 fi
16442 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16443 fi
16444 fi
16445
16446 # Now new_path has a complete unix path to the binary
16447 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16448 # Keep paths in /bin as-is, but remove trailing .exe if any
16449 new_path="${new_path/%.exe/}"
16450 # Do not save /bin paths to all_fixpath_prefixes!
16451 else
16452 # Not in mixed or Windows style, start by that.
16453 new_path=`cmd //c echo $new_path`
16454
16455 input_path="$new_path"
16456 # Check if we need to convert this using DOS-style short mode. If the path
16457 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16458 # take no chances and rewrite it.
16459 # Note: m4 eats our [], so we need to use [ and ] instead.
16460 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16461 if test "x$has_forbidden_chars" != x; then
16462 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16463 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16464 fi
16465
16466 # Output is in $new_path
16467
16468 windows_path="$new_path"
16469 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16470 unix_path=`$CYGPATH -u "$windows_path"`
16471 new_path="$unix_path"
16472 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16473 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16474 new_path="$unix_path"
16475 fi
16476
16477 # remove trailing .exe if any
16478 new_path="${new_path/%.exe/}"
16479
16480 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16481 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16482 fi
16483
16484 else
16485 # We're on a unix platform. Hooray! :)
16486 # First separate the path from the arguments. This will split at the first
16487 # space.
16488 complete="$FOUND_MAKE"
16489 path="${complete%% *}"
16490 tmp="$complete EOL"
16491 arguments="${tmp#* }"
16492
16493 # Cannot rely on the command "which" here since it doesn't always work.
16494 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16495 if test -z "$is_absolute_path"; then
16496 # Path to executable is not absolute. Find it.
16497 IFS_save="$IFS"
16498 IFS=:
16499 for p in $PATH; do
16500 if test -f "$p/$path" && test -x "$p/$path"; then
16501 new_path="$p/$path"
16502 break
16503 fi
16504 done
16505 IFS="$IFS_save"
16506 else
16507 # This is an absolute path, we can use it without further modifications.
16508 new_path="$path"
16509 fi
16510
16511 if test "x$new_path" = x; then
16512 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16513 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16514 has_space=`$ECHO "$complete" | $GREP " "`
16515 if test "x$has_space" != x; then
16516 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16517 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16518 fi
16519 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16520 fi
16521 fi
16522
16523 # Now join together the path and the arguments once again
16524 if test "x$arguments" != xEOL; then
16525 new_complete="$new_path ${arguments% *}"
16526 else
16527 new_complete="$new_path"
16528 fi
16529
16530 if test "x$complete" != "x$new_complete"; then
16531 FOUND_MAKE="$new_complete"
16532 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16533 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16534 fi
16535 fi
16536
16537 fi
16538 fi
16539 fi
16540 fi
16541
16542 fi
16543
16544 if test "x$FOUND_MAKE" = x; then
16545 if test "x$TOOLCHAIN_PATH" != x; then
16546 # We have a toolchain path, check that as well before giving up.
16547 OLD_PATH=$PATH
16548 PATH=$TOOLCHAIN_PATH:$PATH
16549 for ac_prog in gmake
16550 do
16551 # Extract the first word of "$ac_prog", so it can be a program name with args.
16552 set dummy $ac_prog; ac_word=$2
16553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16554 $as_echo_n "checking for $ac_word... " >&6; }
16555 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16556 $as_echo_n "(cached) " >&6
16557 else
16558 case $CHECK_TOOLSDIR_GMAKE in
16559 [\\/]* | ?:[\\/]*)
16560 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16561 ;;
16562 *)
16563 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16564 for as_dir in $PATH
16565 do
16566 IFS=$as_save_IFS
16567 test -z "$as_dir" && as_dir=.
16568 for ac_exec_ext in '' $ac_executable_extensions; do
16569 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16570 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16571 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16572 break 2
16573 fi
16574 done
16575 done
16576 IFS=$as_save_IFS
16577
16578 ;;
16579 esac
16580 fi
16581 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16582 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16584 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16585 else
16586 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16587 $as_echo "no" >&6; }
16588 fi
16589
16590
16591 test -n "$CHECK_TOOLSDIR_GMAKE" && break
16592 done
16593
16594
16595 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16596 DESCRIPTION="gmake in tools-dir"
16597 if test "x$MAKE_CANDIDATE" != x; then
16598 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16599 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16600 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16601 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16602 if test "x$IS_GNU_MAKE" = x; then
16603 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16604 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16605 else
16606 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16607 if test "x$IS_MODERN_MAKE" = x; then
16608 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16609 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16610 else
16611 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16612 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16613 MAKE_EXPECTED_ENV='cygwin'
16614 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16615 MAKE_EXPECTED_ENV='msys'
16616 else
16617 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16618 fi
16619 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16620 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16621 else
16622 # Not relevant for non-Windows
16623 IS_MAKE_CORRECT_ENV=true
16624 fi
16625 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16626 { $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
16627 $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;}
16628 else
16629 FOUND_MAKE=$MAKE_CANDIDATE
16630
16631 # Only process if variable expands to non-empty
16632
16633 if test "x$FOUND_MAKE" != x; then
16634 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16635
16636 # First separate the path from the arguments. This will split at the first
16637 # space.
16638 complete="$FOUND_MAKE"
16639 path="${complete%% *}"
16640 tmp="$complete EOL"
16641 arguments="${tmp#* }"
16642
16643 # Input might be given as Windows format, start by converting to
16644 # unix format.
16645 new_path=`$CYGPATH -u "$path"`
16646
16647 # Now try to locate executable using which
16648 new_path=`$WHICH "$new_path" 2> /dev/null`
16649 # bat and cmd files are not always considered executable in cygwin causing which
16650 # to not find them
16651 if test "x$new_path" = x \
16652 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16653 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16654 new_path=`$CYGPATH -u "$path"`
16655 fi
16656 if test "x$new_path" = x; then
16657 # Oops. Which didn't find the executable.
16658 # The splitting of arguments from the executable at a space might have been incorrect,
16659 # since paths with space are more likely in Windows. Give it another try with the whole
16660 # argument.
16661 path="$complete"
16662 arguments="EOL"
16663 new_path=`$CYGPATH -u "$path"`
16664 new_path=`$WHICH "$new_path" 2> /dev/null`
16665 # bat and cmd files are not always considered executable in cygwin causing which
16666 # to not find them
16667 if test "x$new_path" = x \
16668 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16669 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16670 new_path=`$CYGPATH -u "$path"`
16671 fi
16672 if test "x$new_path" = x; then
16673 # It's still not found. Now this is an unrecoverable error.
16674 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16675 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16676 has_space=`$ECHO "$complete" | $GREP " "`
16677 if test "x$has_space" != x; then
16678 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16679 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16680 fi
16681 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16682 fi
16683 fi
16684
16685 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16686 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16687 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16688 # "foo.exe" is OK but "foo" is an error.
16689 #
16690 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16691 # It is also a way to make sure we got the proper file name for the real test later on.
16692 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16693 if test "x$test_shortpath" = x; then
16694 # Short path failed, file does not exist as specified.
16695 # Try adding .exe or .cmd
16696 if test -f "${new_path}.exe"; then
16697 input_to_shortpath="${new_path}.exe"
16698 elif test -f "${new_path}.cmd"; then
16699 input_to_shortpath="${new_path}.cmd"
16700 else
16701 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16702 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16703 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16704 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16705 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16706 fi
16707 else
16708 input_to_shortpath="$new_path"
16709 fi
16710
16711 # Call helper function which possibly converts this using DOS-style short mode.
16712 # If so, the updated path is stored in $new_path.
16713 new_path="$input_to_shortpath"
16714
16715 input_path="$input_to_shortpath"
16716 # Check if we need to convert this using DOS-style short mode. If the path
16717 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16718 # take no chances and rewrite it.
16719 # Note: m4 eats our [], so we need to use [ and ] instead.
16720 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16721 if test "x$has_forbidden_chars" != x; then
16722 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16723 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16724 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16725 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16726 # Going to short mode and back again did indeed matter. Since short mode is
16727 # case insensitive, let's make it lowercase to improve readability.
16728 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16729 # Now convert it back to Unix-stile (cygpath)
16730 input_path=`$CYGPATH -u "$shortmode_path"`
16731 new_path="$input_path"
16732 fi
16733 fi
16734
16735 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16736 if test "x$test_cygdrive_prefix" = x; then
16737 # As a simple fix, exclude /usr/bin since it's not a real path.
16738 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16739 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16740 # a path prefixed by /cygdrive for fixpath to work.
16741 new_path="$CYGWIN_ROOT_PATH$input_path"
16742 fi
16743 fi
16744
16745 # remove trailing .exe if any
16746 new_path="${new_path/%.exe/}"
16747
16748 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16749
16750 # First separate the path from the arguments. This will split at the first
16751 # space.
16752 complete="$FOUND_MAKE"
16753 path="${complete%% *}"
16754 tmp="$complete EOL"
16755 arguments="${tmp#* }"
16756
16757 # Input might be given as Windows format, start by converting to
16758 # unix format.
16759 new_path="$path"
16760
16761 windows_path="$new_path"
16762 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16763 unix_path=`$CYGPATH -u "$windows_path"`
16764 new_path="$unix_path"
16765 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16766 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16767 new_path="$unix_path"
16768 fi
16769
16770
16771 # Now try to locate executable using which
16772 new_path=`$WHICH "$new_path" 2> /dev/null`
16773
16774 if test "x$new_path" = x; then
16775 # Oops. Which didn't find the executable.
16776 # The splitting of arguments from the executable at a space might have been incorrect,
16777 # since paths with space are more likely in Windows. Give it another try with the whole
16778 # argument.
16779 path="$complete"
16780 arguments="EOL"
16781 new_path="$path"
16782
16783 windows_path="$new_path"
16784 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16785 unix_path=`$CYGPATH -u "$windows_path"`
16786 new_path="$unix_path"
16787 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16788 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16789 new_path="$unix_path"
16790 fi
16791
16792
16793 new_path=`$WHICH "$new_path" 2> /dev/null`
16794 # bat and cmd files are not always considered executable in MSYS causing which
16795 # to not find them
16796 if test "x$new_path" = x \
16797 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16798 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16799 new_path="$path"
16800
16801 windows_path="$new_path"
16802 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16803 unix_path=`$CYGPATH -u "$windows_path"`
16804 new_path="$unix_path"
16805 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16806 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16807 new_path="$unix_path"
16808 fi
16809
16810 fi
16811
16812 if test "x$new_path" = x; then
16813 # It's still not found. Now this is an unrecoverable error.
16814 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16815 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16816 has_space=`$ECHO "$complete" | $GREP " "`
16817 if test "x$has_space" != x; then
16818 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16819 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16820 fi
16821 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16822 fi
16823 fi
16824
16825 # Now new_path has a complete unix path to the binary
16826 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16827 # Keep paths in /bin as-is, but remove trailing .exe if any
16828 new_path="${new_path/%.exe/}"
16829 # Do not save /bin paths to all_fixpath_prefixes!
16830 else
16831 # Not in mixed or Windows style, start by that.
16832 new_path=`cmd //c echo $new_path`
16833
16834 input_path="$new_path"
16835 # Check if we need to convert this using DOS-style short mode. If the path
16836 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16837 # take no chances and rewrite it.
16838 # Note: m4 eats our [], so we need to use [ and ] instead.
16839 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16840 if test "x$has_forbidden_chars" != x; then
16841 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16842 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16843 fi
16844
16845 # Output is in $new_path
16846
16847 windows_path="$new_path"
16848 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16849 unix_path=`$CYGPATH -u "$windows_path"`
16850 new_path="$unix_path"
16851 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16852 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16853 new_path="$unix_path"
16854 fi
16855
16856 # remove trailing .exe if any
16857 new_path="${new_path/%.exe/}"
16858
16859 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16860 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16861 fi
16862
16863 else
16864 # We're on a unix platform. Hooray! :)
16865 # First separate the path from the arguments. This will split at the first
16866 # space.
16867 complete="$FOUND_MAKE"
16868 path="${complete%% *}"
16869 tmp="$complete EOL"
16870 arguments="${tmp#* }"
16871
16872 # Cannot rely on the command "which" here since it doesn't always work.
16873 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16874 if test -z "$is_absolute_path"; then
16875 # Path to executable is not absolute. Find it.
16876 IFS_save="$IFS"
16877 IFS=:
16878 for p in $PATH; do
16879 if test -f "$p/$path" && test -x "$p/$path"; then
16880 new_path="$p/$path"
16881 break
16882 fi
16883 done
16884 IFS="$IFS_save"
16885 else
16886 # This is an absolute path, we can use it without further modifications.
16887 new_path="$path"
16888 fi
16889
16890 if test "x$new_path" = x; then
16891 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16892 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16893 has_space=`$ECHO "$complete" | $GREP " "`
16894 if test "x$has_space" != x; then
16895 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16896 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16897 fi
16898 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16899 fi
16900 fi
16901
16902 # Now join together the path and the arguments once again
16903 if test "x$arguments" != xEOL; then
16904 new_complete="$new_path ${arguments% *}"
16905 else
16906 new_complete="$new_path"
16907 fi
16908
16909 if test "x$complete" != "x$new_complete"; then
16910 FOUND_MAKE="$new_complete"
16911 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16912 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16913 fi
16914 fi
16915
16916 fi
16917 fi
16918 fi
16919 fi
16920
16921 if test "x$FOUND_MAKE" = x; then
16922 for ac_prog in make
16923 do
16924 # Extract the first word of "$ac_prog", so it can be a program name with args.
16925 set dummy $ac_prog; ac_word=$2
16926 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16927 $as_echo_n "checking for $ac_word... " >&6; }
16928 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16929 $as_echo_n "(cached) " >&6
16930 else
16931 case $CHECK_TOOLSDIR_MAKE in
16932 [\\/]* | ?:[\\/]*)
16933 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16934 ;;
16935 *)
16936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16937 for as_dir in $PATH
16938 do
16939 IFS=$as_save_IFS
16940 test -z "$as_dir" && as_dir=.
16941 for ac_exec_ext in '' $ac_executable_extensions; do
16942 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16943 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16944 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16945 break 2
16946 fi
16947 done
16948 done
16949 IFS=$as_save_IFS
16950
16951 ;;
16952 esac
16953 fi
16954 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16955 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16956 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16957 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16958 else
16959 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16960 $as_echo "no" >&6; }
16961 fi
16962
16963
16964 test -n "$CHECK_TOOLSDIR_MAKE" && break
16965 done
16966
16967
16968 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16969 DESCRIPTION="make in tools-dir"
16970 if test "x$MAKE_CANDIDATE" != x; then
16971 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16972 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16973 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16974 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16975 if test "x$IS_GNU_MAKE" = x; then
16976 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16977 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16978 else
16979 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16980 if test "x$IS_MODERN_MAKE" = x; then
16981 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16982 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16983 else
16984 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16985 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16986 MAKE_EXPECTED_ENV='cygwin'
16987 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16988 MAKE_EXPECTED_ENV='msys'
16989 else
16990 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16991 fi
16992 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16993 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16994 else
16995 # Not relevant for non-Windows
16996 IS_MAKE_CORRECT_ENV=true
16997 fi
16998 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16999 { $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
17000 $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;}
17001 else
17002 FOUND_MAKE=$MAKE_CANDIDATE
17003
17004 # Only process if variable expands to non-empty
17005
17006 if test "x$FOUND_MAKE" != x; then
17007 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17008
17009 # First separate the path from the arguments. This will split at the first
17010 # space.
17011 complete="$FOUND_MAKE"
17012 path="${complete%% *}"
17013 tmp="$complete EOL"
17014 arguments="${tmp#* }"
17015
17016 # Input might be given as Windows format, start by converting to
17017 # unix format.
17018 new_path=`$CYGPATH -u "$path"`
17019
17020 # Now try to locate executable using which
17021 new_path=`$WHICH "$new_path" 2> /dev/null`
17022 # bat and cmd files are not always considered executable in cygwin causing which
17023 # to not find them
17024 if test "x$new_path" = x \
17025 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17026 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17027 new_path=`$CYGPATH -u "$path"`
17028 fi
17029 if test "x$new_path" = x; then
17030 # Oops. Which didn't find the executable.
17031 # The splitting of arguments from the executable at a space might have been incorrect,
17032 # since paths with space are more likely in Windows. Give it another try with the whole
17033 # argument.
17034 path="$complete"
17035 arguments="EOL"
17036 new_path=`$CYGPATH -u "$path"`
17037 new_path=`$WHICH "$new_path" 2> /dev/null`
17038 # bat and cmd files are not always considered executable in cygwin causing which
17039 # to not find them
17040 if test "x$new_path" = x \
17041 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17042 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17043 new_path=`$CYGPATH -u "$path"`
17044 fi
17045 if test "x$new_path" = x; then
17046 # It's still not found. Now this is an unrecoverable error.
17047 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17048 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17049 has_space=`$ECHO "$complete" | $GREP " "`
17050 if test "x$has_space" != x; then
17051 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17052 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17053 fi
17054 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17055 fi
17056 fi
17057
17058 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17059 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17060 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17061 # "foo.exe" is OK but "foo" is an error.
17062 #
17063 # This test is therefore slightly more accurate than "test -f" to check for file presence.
17064 # It is also a way to make sure we got the proper file name for the real test later on.
17065 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17066 if test "x$test_shortpath" = x; then
17067 # Short path failed, file does not exist as specified.
17068 # Try adding .exe or .cmd
17069 if test -f "${new_path}.exe"; then
17070 input_to_shortpath="${new_path}.exe"
17071 elif test -f "${new_path}.cmd"; then
17072 input_to_shortpath="${new_path}.cmd"
17073 else
17074 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17075 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17076 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17077 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17078 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17079 fi
17080 else
17081 input_to_shortpath="$new_path"
17082 fi
17083
17084 # Call helper function which possibly converts this using DOS-style short mode.
17085 # If so, the updated path is stored in $new_path.
17086 new_path="$input_to_shortpath"
17087
17088 input_path="$input_to_shortpath"
17089 # Check if we need to convert this using DOS-style short mode. If the path
17090 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17091 # take no chances and rewrite it.
17092 # Note: m4 eats our [], so we need to use [ and ] instead.
17093 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17094 if test "x$has_forbidden_chars" != x; then
17095 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17096 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17097 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17098 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17099 # Going to short mode and back again did indeed matter. Since short mode is
17100 # case insensitive, let's make it lowercase to improve readability.
17101 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17102 # Now convert it back to Unix-stile (cygpath)
17103 input_path=`$CYGPATH -u "$shortmode_path"`
17104 new_path="$input_path"
17105 fi
17106 fi
17107
17108 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17109 if test "x$test_cygdrive_prefix" = x; then
17110 # As a simple fix, exclude /usr/bin since it's not a real path.
17111 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17112 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17113 # a path prefixed by /cygdrive for fixpath to work.
17114 new_path="$CYGWIN_ROOT_PATH$input_path"
17115 fi
17116 fi
17117
17118 # remove trailing .exe if any
17119 new_path="${new_path/%.exe/}"
17120
17121 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17122
17123 # First separate the path from the arguments. This will split at the first
17124 # space.
17125 complete="$FOUND_MAKE"
17126 path="${complete%% *}"
17127 tmp="$complete EOL"
17128 arguments="${tmp#* }"
17129
17130 # Input might be given as Windows format, start by converting to
17131 # unix format.
17132 new_path="$path"
17133
17134 windows_path="$new_path"
17135 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17136 unix_path=`$CYGPATH -u "$windows_path"`
17137 new_path="$unix_path"
17138 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17139 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17140 new_path="$unix_path"
17141 fi
17142
17143
17144 # Now try to locate executable using which
17145 new_path=`$WHICH "$new_path" 2> /dev/null`
17146
17147 if test "x$new_path" = x; then
17148 # Oops. Which didn't find the executable.
17149 # The splitting of arguments from the executable at a space might have been incorrect,
17150 # since paths with space are more likely in Windows. Give it another try with the whole
17151 # argument.
17152 path="$complete"
17153 arguments="EOL"
17154 new_path="$path"
17155
17156 windows_path="$new_path"
17157 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17158 unix_path=`$CYGPATH -u "$windows_path"`
17159 new_path="$unix_path"
17160 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17161 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17162 new_path="$unix_path"
17163 fi
17164
17165
17166 new_path=`$WHICH "$new_path" 2> /dev/null`
17167 # bat and cmd files are not always considered executable in MSYS causing which
17168 # to not find them
17169 if test "x$new_path" = x \
17170 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17171 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17172 new_path="$path"
17173
17174 windows_path="$new_path"
17175 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17176 unix_path=`$CYGPATH -u "$windows_path"`
17177 new_path="$unix_path"
17178 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17179 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17180 new_path="$unix_path"
17181 fi
17182
17183 fi
17184
17185 if test "x$new_path" = x; then
17186 # It's still not found. Now this is an unrecoverable error.
17187 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17188 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17189 has_space=`$ECHO "$complete" | $GREP " "`
17190 if test "x$has_space" != x; then
17191 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17192 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17193 fi
17194 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17195 fi
17196 fi
17197
17198 # Now new_path has a complete unix path to the binary
17199 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17200 # Keep paths in /bin as-is, but remove trailing .exe if any
17201 new_path="${new_path/%.exe/}"
17202 # Do not save /bin paths to all_fixpath_prefixes!
17203 else
17204 # Not in mixed or Windows style, start by that.
17205 new_path=`cmd //c echo $new_path`
17206
17207 input_path="$new_path"
17208 # Check if we need to convert this using DOS-style short mode. If the path
17209 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17210 # take no chances and rewrite it.
17211 # Note: m4 eats our [], so we need to use [ and ] instead.
17212 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17213 if test "x$has_forbidden_chars" != x; then
17214 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17215 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17216 fi
17217
17218 # Output is in $new_path
17219
17220 windows_path="$new_path"
17221 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17222 unix_path=`$CYGPATH -u "$windows_path"`
17223 new_path="$unix_path"
17224 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17225 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17226 new_path="$unix_path"
17227 fi
17228
17229 # remove trailing .exe if any
17230 new_path="${new_path/%.exe/}"
17231
17232 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17233 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17234 fi
17235
17236 else
17237 # We're on a unix platform. Hooray! :)
17238 # First separate the path from the arguments. This will split at the first
17239 # space.
17240 complete="$FOUND_MAKE"
17241 path="${complete%% *}"
17242 tmp="$complete EOL"
17243 arguments="${tmp#* }"
17244
17245 # Cannot rely on the command "which" here since it doesn't always work.
17246 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17247 if test -z "$is_absolute_path"; then
17248 # Path to executable is not absolute. Find it.
17249 IFS_save="$IFS"
17250 IFS=:
17251 for p in $PATH; do
17252 if test -f "$p/$path" && test -x "$p/$path"; then
17253 new_path="$p/$path"
17254 break
17255 fi
17256 done
17257 IFS="$IFS_save"
17258 else
17259 # This is an absolute path, we can use it without further modifications.
17260 new_path="$path"
17261 fi
17262
17263 if test "x$new_path" = x; then
17264 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17265 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17266 has_space=`$ECHO "$complete" | $GREP " "`
17267 if test "x$has_space" != x; then
17268 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17269 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17270 fi
17271 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17272 fi
17273 fi
17274
17275 # Now join together the path and the arguments once again
17276 if test "x$arguments" != xEOL; then
17277 new_complete="$new_path ${arguments% *}"
17278 else
17279 new_complete="$new_path"
17280 fi
17281
17282 if test "x$complete" != "x$new_complete"; then
17283 FOUND_MAKE="$new_complete"
17284 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17285 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17286 fi
17287 fi
17288
17289 fi
17290 fi
17291 fi
17292 fi
17293
17294 fi
17295 PATH=$OLD_PATH
17296 fi
17297 fi
17298
17299 if test "x$FOUND_MAKE" = x; then
17300 as_fn_error $? "Cannot find GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
17301 fi
17302 fi
17303
17304 MAKE=$FOUND_MAKE
17305
17306 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17307 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17308
17309
17310 # Check if make supports the output sync option and if so, setup using it.
17311 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
17312 $as_echo_n "checking if make --output-sync is supported... " >&6; }
17313 if $MAKE --version -O > /dev/null 2>&1; then
17314 OUTPUT_SYNC_SUPPORTED=true
17315 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17316 $as_echo "yes" >&6; }
17317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
17318 $as_echo_n "checking for output-sync value... " >&6; }
17319
17320 # Check whether --with-output-sync was given.
17321 if test "${with_output_sync+set}" = set; then :
17322 withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
17323 fi
17324
17325 if test "x$OUTPUT_SYNC" = "x"; then
17326 OUTPUT_SYNC=none
17327 fi
17328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
17329 $as_echo "$OUTPUT_SYNC" >&6; }
17330 if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
17331 as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
17332 fi
17333 else
17334 OUTPUT_SYNC_SUPPORTED=false
17335 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17336 $as_echo "no" >&6; }
17337 fi
17338
17339
17340
17341
17342
17343
17344 # Test if find supports -delete
17345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17346 $as_echo_n "checking if find supports -delete... " >&6; }
17347 FIND_DELETE="-delete"
17348
17349 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17350
17351 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17352
17353 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17354 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17355 # No, it does not.
17356 rm $DELETEDIR/TestIfFindSupportsDelete
17357 if test "x$OPENJDK_TARGET_OS" = "xaix"; then
17358 # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
17359 FIND_DELETE="-print | xargs rm"
17360 else
17361 FIND_DELETE="-exec rm \{\} \+"
17362 fi
17363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17364 $as_echo "no" >&6; }
17365 else
17366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17367 $as_echo "yes" >&6; }
17368 fi
17369 rmdir $DELETEDIR
17370
17371
17372
17373 # These tools might not be installed by default,
17374 # need hint on how to install them.
17375
17376
17377
17378 # Publish this variable in the help.
17379
17380
17381 if test "x$UNZIP" = x; then
17382 # The variable is not set by user, try to locate tool using the code snippet
17383 for ac_prog in unzip
17384 do
17385 # Extract the first word of "$ac_prog", so it can be a program name with args.
17386 set dummy $ac_prog; ac_word=$2
17387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17388 $as_echo_n "checking for $ac_word... " >&6; }
17389 if ${ac_cv_path_UNZIP+:} false; then :
17390 $as_echo_n "(cached) " >&6
17391 else
17392 case $UNZIP in
17393 [\\/]* | ?:[\\/]*)
17394 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17395 ;;
17396 *)
17397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17398 for as_dir in $PATH
17399 do
17400 IFS=$as_save_IFS
17401 test -z "$as_dir" && as_dir=.
17402 for ac_exec_ext in '' $ac_executable_extensions; do
17403 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17404 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17405 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17406 break 2
17407 fi
17408 done
17409 done
17410 IFS=$as_save_IFS
17411
17412 ;;
17413 esac
17414 fi
17415 UNZIP=$ac_cv_path_UNZIP
17416 if test -n "$UNZIP"; then
17417 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17418 $as_echo "$UNZIP" >&6; }
17419 else
17420 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17421 $as_echo "no" >&6; }
17422 fi
17423
17424
17425 test -n "$UNZIP" && break
17426 done
17427
17428 else
17429 # The variable is set, but is it from the command line or the environment?
17430
17431 # Try to remove the string !UNZIP! from our list.
17432 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17433 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17434 # If it failed, the variable was not from the command line. Ignore it,
17435 # but warn the user (except for BASH, which is always set by the calling BASH).
17436 if test "xUNZIP" != xBASH; then
17437 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17438 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17439 fi
17440 # Try to locate tool using the code snippet
17441 for ac_prog in unzip
17442 do
17443 # Extract the first word of "$ac_prog", so it can be a program name with args.
17444 set dummy $ac_prog; ac_word=$2
17445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17446 $as_echo_n "checking for $ac_word... " >&6; }
17447 if ${ac_cv_path_UNZIP+:} false; then :
17448 $as_echo_n "(cached) " >&6
17449 else
17450 case $UNZIP in
17451 [\\/]* | ?:[\\/]*)
17452 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17453 ;;
17454 *)
17455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17456 for as_dir in $PATH
17457 do
17458 IFS=$as_save_IFS
17459 test -z "$as_dir" && as_dir=.
17460 for ac_exec_ext in '' $ac_executable_extensions; do
17461 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17462 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17463 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17464 break 2
17465 fi
17466 done
17467 done
17468 IFS=$as_save_IFS
17469
17470 ;;
17471 esac
17472 fi
17473 UNZIP=$ac_cv_path_UNZIP
17474 if test -n "$UNZIP"; then
17475 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17476 $as_echo "$UNZIP" >&6; }
17477 else
17478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17479 $as_echo "no" >&6; }
17480 fi
17481
17482
17483 test -n "$UNZIP" && break
17484 done
17485
17486 else
17487 # If it succeeded, then it was overridden by the user. We will use it
17488 # for the tool.
17489
17490 # First remove it from the list of overridden variables, so we can test
17491 # for unknown variables in the end.
17492 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17493
17494 # Check if the provided tool contains a complete path.
17495 tool_specified="$UNZIP"
17496 tool_basename="${tool_specified##*/}"
17497 if test "x$tool_basename" = "x$tool_specified"; then
17498 # A command without a complete path is provided, search $PATH.
17499 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17500 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17501 # Extract the first word of "$tool_basename", so it can be a program name with args.
17502 set dummy $tool_basename; ac_word=$2
17503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17504 $as_echo_n "checking for $ac_word... " >&6; }
17505 if ${ac_cv_path_UNZIP+:} false; then :
17506 $as_echo_n "(cached) " >&6
17507 else
17508 case $UNZIP in
17509 [\\/]* | ?:[\\/]*)
17510 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17511 ;;
17512 *)
17513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17514 for as_dir in $PATH
17515 do
17516 IFS=$as_save_IFS
17517 test -z "$as_dir" && as_dir=.
17518 for ac_exec_ext in '' $ac_executable_extensions; do
17519 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17520 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17521 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17522 break 2
17523 fi
17524 done
17525 done
17526 IFS=$as_save_IFS
17527
17528 ;;
17529 esac
17530 fi
17531 UNZIP=$ac_cv_path_UNZIP
17532 if test -n "$UNZIP"; then
17533 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17534 $as_echo "$UNZIP" >&6; }
17535 else
17536 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17537 $as_echo "no" >&6; }
17538 fi
17539
17540
17541 if test "x$UNZIP" = x; then
17542 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17543 fi
17544 else
17545 # Otherwise we believe it is a complete path. Use it as it is.
17546 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17547 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17549 $as_echo_n "checking for UNZIP... " >&6; }
17550 if test ! -x "$tool_specified"; then
17551 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17552 $as_echo "not found" >&6; }
17553 as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17554 fi
17555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17556 $as_echo "$tool_specified" >&6; }
17557 fi
17558 fi
17559 fi
17560
17561
17562
17563 if test "x$UNZIP" = x; then
17564 as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17565 fi
17566
17567
17568
17569
17570
17571 # Publish this variable in the help.
17572
17573
17574 if test "x$ZIP" = x; then
17575 # The variable is not set by user, try to locate tool using the code snippet
17576 for ac_prog in zip
17577 do
17578 # Extract the first word of "$ac_prog", so it can be a program name with args.
17579 set dummy $ac_prog; ac_word=$2
17580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17581 $as_echo_n "checking for $ac_word... " >&6; }
17582 if ${ac_cv_path_ZIP+:} false; then :
17583 $as_echo_n "(cached) " >&6
17584 else
17585 case $ZIP in
17586 [\\/]* | ?:[\\/]*)
17587 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17588 ;;
17589 *)
17590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17591 for as_dir in $PATH
17592 do
17593 IFS=$as_save_IFS
17594 test -z "$as_dir" && as_dir=.
17595 for ac_exec_ext in '' $ac_executable_extensions; do
17596 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17597 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17598 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17599 break 2
17600 fi
17601 done
17602 done
17603 IFS=$as_save_IFS
17604
17605 ;;
17606 esac
17607 fi
17608 ZIP=$ac_cv_path_ZIP
17609 if test -n "$ZIP"; then
17610 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17611 $as_echo "$ZIP" >&6; }
17612 else
17613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17614 $as_echo "no" >&6; }
17615 fi
17616
17617
17618 test -n "$ZIP" && break
17619 done
17620
17621 else
17622 # The variable is set, but is it from the command line or the environment?
17623
17624 # Try to remove the string !ZIP! from our list.
17625 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17626 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17627 # If it failed, the variable was not from the command line. Ignore it,
17628 # but warn the user (except for BASH, which is always set by the calling BASH).
17629 if test "xZIP" != xBASH; then
17630 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17631 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17632 fi
17633 # Try to locate tool using the code snippet
17634 for ac_prog in zip
17635 do
17636 # Extract the first word of "$ac_prog", so it can be a program name with args.
17637 set dummy $ac_prog; ac_word=$2
17638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17639 $as_echo_n "checking for $ac_word... " >&6; }
17640 if ${ac_cv_path_ZIP+:} false; then :
17641 $as_echo_n "(cached) " >&6
17642 else
17643 case $ZIP in
17644 [\\/]* | ?:[\\/]*)
17645 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17646 ;;
17647 *)
17648 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17649 for as_dir in $PATH
17650 do
17651 IFS=$as_save_IFS
17652 test -z "$as_dir" && as_dir=.
17653 for ac_exec_ext in '' $ac_executable_extensions; do
17654 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17655 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17656 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17657 break 2
17658 fi
17659 done
17660 done
17661 IFS=$as_save_IFS
17662
17663 ;;
17664 esac
17665 fi
17666 ZIP=$ac_cv_path_ZIP
17667 if test -n "$ZIP"; then
17668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17669 $as_echo "$ZIP" >&6; }
17670 else
17671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17672 $as_echo "no" >&6; }
17673 fi
17674
17675
17676 test -n "$ZIP" && break
17677 done
17678
17679 else
17680 # If it succeeded, then it was overridden by the user. We will use it
17681 # for the tool.
17682
17683 # First remove it from the list of overridden variables, so we can test
17684 # for unknown variables in the end.
17685 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17686
17687 # Check if the provided tool contains a complete path.
17688 tool_specified="$ZIP"
17689 tool_basename="${tool_specified##*/}"
17690 if test "x$tool_basename" = "x$tool_specified"; then
17691 # A command without a complete path is provided, search $PATH.
17692 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17693 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17694 # Extract the first word of "$tool_basename", so it can be a program name with args.
17695 set dummy $tool_basename; ac_word=$2
17696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17697 $as_echo_n "checking for $ac_word... " >&6; }
17698 if ${ac_cv_path_ZIP+:} false; then :
17699 $as_echo_n "(cached) " >&6
17700 else
17701 case $ZIP in
17702 [\\/]* | ?:[\\/]*)
17703 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17704 ;;
17705 *)
17706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17707 for as_dir in $PATH
17708 do
17709 IFS=$as_save_IFS
17710 test -z "$as_dir" && as_dir=.
17711 for ac_exec_ext in '' $ac_executable_extensions; do
17712 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17713 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17714 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17715 break 2
17716 fi
17717 done
17718 done
17719 IFS=$as_save_IFS
17720
17721 ;;
17722 esac
17723 fi
17724 ZIP=$ac_cv_path_ZIP
17725 if test -n "$ZIP"; then
17726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17727 $as_echo "$ZIP" >&6; }
17728 else
17729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17730 $as_echo "no" >&6; }
17731 fi
17732
17733
17734 if test "x$ZIP" = x; then
17735 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17736 fi
17737 else
17738 # Otherwise we believe it is a complete path. Use it as it is.
17739 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17740 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17742 $as_echo_n "checking for ZIP... " >&6; }
17743 if test ! -x "$tool_specified"; then
17744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17745 $as_echo "not found" >&6; }
17746 as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17747 fi
17748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17749 $as_echo "$tool_specified" >&6; }
17750 fi
17751 fi
17752 fi
17753
17754
17755
17756 if test "x$ZIP" = x; then
17757 as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17758 fi
17759
17760
17761
17762 # Non-required basic tools
17763
17764
17765
17766 # Publish this variable in the help.
17767
17768
17769 if test "x$LDD" = x; then
17770 # The variable is not set by user, try to locate tool using the code snippet
17771 for ac_prog in ldd
17772 do
17773 # Extract the first word of "$ac_prog", so it can be a program name with args.
17774 set dummy $ac_prog; ac_word=$2
17775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17776 $as_echo_n "checking for $ac_word... " >&6; }
17777 if ${ac_cv_path_LDD+:} false; then :
17778 $as_echo_n "(cached) " >&6
17779 else
17780 case $LDD in
17781 [\\/]* | ?:[\\/]*)
17782 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17783 ;;
17784 *)
17785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17786 for as_dir in $PATH
17787 do
17788 IFS=$as_save_IFS
17789 test -z "$as_dir" && as_dir=.
17790 for ac_exec_ext in '' $ac_executable_extensions; do
17791 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17792 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17793 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17794 break 2
17795 fi
17796 done
17797 done
17798 IFS=$as_save_IFS
17799
17800 ;;
17801 esac
17802 fi
17803 LDD=$ac_cv_path_LDD
17804 if test -n "$LDD"; then
17805 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17806 $as_echo "$LDD" >&6; }
17807 else
17808 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17809 $as_echo "no" >&6; }
17810 fi
17811
17812
17813 test -n "$LDD" && break
17814 done
17815
17816 else
17817 # The variable is set, but is it from the command line or the environment?
17818
17819 # Try to remove the string !LDD! from our list.
17820 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17821 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17822 # If it failed, the variable was not from the command line. Ignore it,
17823 # but warn the user (except for BASH, which is always set by the calling BASH).
17824 if test "xLDD" != xBASH; then
17825 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17826 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17827 fi
17828 # Try to locate tool using the code snippet
17829 for ac_prog in ldd
17830 do
17831 # Extract the first word of "$ac_prog", so it can be a program name with args.
17832 set dummy $ac_prog; ac_word=$2
17833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17834 $as_echo_n "checking for $ac_word... " >&6; }
17835 if ${ac_cv_path_LDD+:} false; then :
17836 $as_echo_n "(cached) " >&6
17837 else
17838 case $LDD in
17839 [\\/]* | ?:[\\/]*)
17840 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17841 ;;
17842 *)
17843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17844 for as_dir in $PATH
17845 do
17846 IFS=$as_save_IFS
17847 test -z "$as_dir" && as_dir=.
17848 for ac_exec_ext in '' $ac_executable_extensions; do
17849 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17850 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17851 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17852 break 2
17853 fi
17854 done
17855 done
17856 IFS=$as_save_IFS
17857
17858 ;;
17859 esac
17860 fi
17861 LDD=$ac_cv_path_LDD
17862 if test -n "$LDD"; then
17863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17864 $as_echo "$LDD" >&6; }
17865 else
17866 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17867 $as_echo "no" >&6; }
17868 fi
17869
17870
17871 test -n "$LDD" && break
17872 done
17873
17874 else
17875 # If it succeeded, then it was overridden by the user. We will use it
17876 # for the tool.
17877
17878 # First remove it from the list of overridden variables, so we can test
17879 # for unknown variables in the end.
17880 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17881
17882 # Check if the provided tool contains a complete path.
17883 tool_specified="$LDD"
17884 tool_basename="${tool_specified##*/}"
17885 if test "x$tool_basename" = "x$tool_specified"; then
17886 # A command without a complete path is provided, search $PATH.
17887 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17888 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17889 # Extract the first word of "$tool_basename", so it can be a program name with args.
17890 set dummy $tool_basename; ac_word=$2
17891 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17892 $as_echo_n "checking for $ac_word... " >&6; }
17893 if ${ac_cv_path_LDD+:} false; then :
17894 $as_echo_n "(cached) " >&6
17895 else
17896 case $LDD in
17897 [\\/]* | ?:[\\/]*)
17898 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17899 ;;
17900 *)
17901 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17902 for as_dir in $PATH
17903 do
17904 IFS=$as_save_IFS
17905 test -z "$as_dir" && as_dir=.
17906 for ac_exec_ext in '' $ac_executable_extensions; do
17907 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17908 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17909 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17910 break 2
17911 fi
17912 done
17913 done
17914 IFS=$as_save_IFS
17915
17916 ;;
17917 esac
17918 fi
17919 LDD=$ac_cv_path_LDD
17920 if test -n "$LDD"; then
17921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17922 $as_echo "$LDD" >&6; }
17923 else
17924 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17925 $as_echo "no" >&6; }
17926 fi
17927
17928
17929 if test "x$LDD" = x; then
17930 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17931 fi
17932 else
17933 # Otherwise we believe it is a complete path. Use it as it is.
17934 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17935 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17936 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17937 $as_echo_n "checking for LDD... " >&6; }
17938 if test ! -x "$tool_specified"; then
17939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17940 $as_echo "not found" >&6; }
17941 as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17942 fi
17943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17944 $as_echo "$tool_specified" >&6; }
17945 fi
17946 fi
17947 fi
17948
17949
17950 if test "x$LDD" = "x"; then
17951 # List shared lib dependencies is used for
17952 # debug output and checking for forbidden dependencies.
17953 # We can build without it.
17954 LDD="true"
17955 fi
17956
17957
17958 # Publish this variable in the help.
17959
17960
17961 if test "x$OTOOL" = x; then
17962 # The variable is not set by user, try to locate tool using the code snippet
17963 for ac_prog in otool
17964 do
17965 # Extract the first word of "$ac_prog", so it can be a program name with args.
17966 set dummy $ac_prog; ac_word=$2
17967 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17968 $as_echo_n "checking for $ac_word... " >&6; }
17969 if ${ac_cv_path_OTOOL+:} false; then :
17970 $as_echo_n "(cached) " >&6
17971 else
17972 case $OTOOL in
17973 [\\/]* | ?:[\\/]*)
17974 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17975 ;;
17976 *)
17977 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17978 for as_dir in $PATH
17979 do
17980 IFS=$as_save_IFS
17981 test -z "$as_dir" && as_dir=.
17982 for ac_exec_ext in '' $ac_executable_extensions; do
17983 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17984 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17985 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17986 break 2
17987 fi
17988 done
17989 done
17990 IFS=$as_save_IFS
17991
17992 ;;
17993 esac
17994 fi
17995 OTOOL=$ac_cv_path_OTOOL
17996 if test -n "$OTOOL"; then
17997 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17998 $as_echo "$OTOOL" >&6; }
17999 else
18000 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18001 $as_echo "no" >&6; }
18002 fi
18003
18004
18005 test -n "$OTOOL" && break
18006 done
18007
18008 else
18009 # The variable is set, but is it from the command line or the environment?
18010
18011 # Try to remove the string !OTOOL! from our list.
18012 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
18013 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18014 # If it failed, the variable was not from the command line. Ignore it,
18015 # but warn the user (except for BASH, which is always set by the calling BASH).
18016 if test "xOTOOL" != xBASH; then
18017 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
18018 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
18019 fi
18020 # Try to locate tool using the code snippet
18021 for ac_prog in otool
18022 do
18023 # Extract the first word of "$ac_prog", so it can be a program name with args.
18024 set dummy $ac_prog; ac_word=$2
18025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18026 $as_echo_n "checking for $ac_word... " >&6; }
18027 if ${ac_cv_path_OTOOL+:} false; then :
18028 $as_echo_n "(cached) " >&6
18029 else
18030 case $OTOOL in
18031 [\\/]* | ?:[\\/]*)
18032 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18033 ;;
18034 *)
18035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18036 for as_dir in $PATH
18037 do
18038 IFS=$as_save_IFS
18039 test -z "$as_dir" && as_dir=.
18040 for ac_exec_ext in '' $ac_executable_extensions; do
18041 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18042 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18043 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18044 break 2
18045 fi
18046 done
18047 done
18048 IFS=$as_save_IFS
18049
18050 ;;
18051 esac
18052 fi
18053 OTOOL=$ac_cv_path_OTOOL
18054 if test -n "$OTOOL"; then
18055 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18056 $as_echo "$OTOOL" >&6; }
18057 else
18058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18059 $as_echo "no" >&6; }
18060 fi
18061
18062
18063 test -n "$OTOOL" && break
18064 done
18065
18066 else
18067 # If it succeeded, then it was overridden by the user. We will use it
18068 # for the tool.
18069
18070 # First remove it from the list of overridden variables, so we can test
18071 # for unknown variables in the end.
18072 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18073
18074 # Check if the provided tool contains a complete path.
18075 tool_specified="$OTOOL"
18076 tool_basename="${tool_specified##*/}"
18077 if test "x$tool_basename" = "x$tool_specified"; then
18078 # A command without a complete path is provided, search $PATH.
18079 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
18080 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
18081 # Extract the first word of "$tool_basename", so it can be a program name with args.
18082 set dummy $tool_basename; ac_word=$2
18083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18084 $as_echo_n "checking for $ac_word... " >&6; }
18085 if ${ac_cv_path_OTOOL+:} false; then :
18086 $as_echo_n "(cached) " >&6
18087 else
18088 case $OTOOL in
18089 [\\/]* | ?:[\\/]*)
18090 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18091 ;;
18092 *)
18093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18094 for as_dir in $PATH
18095 do
18096 IFS=$as_save_IFS
18097 test -z "$as_dir" && as_dir=.
18098 for ac_exec_ext in '' $ac_executable_extensions; do
18099 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18100 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18101 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18102 break 2
18103 fi
18104 done
18105 done
18106 IFS=$as_save_IFS
18107
18108 ;;
18109 esac
18110 fi
18111 OTOOL=$ac_cv_path_OTOOL
18112 if test -n "$OTOOL"; then
18113 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18114 $as_echo "$OTOOL" >&6; }
18115 else
18116 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18117 $as_echo "no" >&6; }
18118 fi
18119
18120
18121 if test "x$OTOOL" = x; then
18122 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18123 fi
18124 else
18125 # Otherwise we believe it is a complete path. Use it as it is.
18126 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
18127 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
18128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
18129 $as_echo_n "checking for OTOOL... " >&6; }
18130 if test ! -x "$tool_specified"; then
18131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18132 $as_echo "not found" >&6; }
18133 as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
18134 fi
18135 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18136 $as_echo "$tool_specified" >&6; }
18137 fi
18138 fi
18139 fi
18140
18141
18142 if test "x$OTOOL" = "x"; then
18143 OTOOL="true"
18144 fi
18145
18146
18147 # Publish this variable in the help.
18148
18149
18150 if test "x$READELF" = x; then
18151 # The variable is not set by user, try to locate tool using the code snippet
18152 for ac_prog in greadelf readelf
18153 do
18154 # Extract the first word of "$ac_prog", so it can be a program name with args.
18155 set dummy $ac_prog; ac_word=$2
18156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18157 $as_echo_n "checking for $ac_word... " >&6; }
18158 if ${ac_cv_path_READELF+:} false; then :
18159 $as_echo_n "(cached) " >&6
18160 else
18161 case $READELF in
18162 [\\/]* | ?:[\\/]*)
18163 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18164 ;;
18165 *)
18166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18167 for as_dir in $PATH
18168 do
18169 IFS=$as_save_IFS
18170 test -z "$as_dir" && as_dir=.
18171 for ac_exec_ext in '' $ac_executable_extensions; do
18172 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18173 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18174 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18175 break 2
18176 fi
18177 done
18178 done
18179 IFS=$as_save_IFS
18180
18181 ;;
18182 esac
18183 fi
18184 READELF=$ac_cv_path_READELF
18185 if test -n "$READELF"; then
18186 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18187 $as_echo "$READELF" >&6; }
18188 else
18189 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18190 $as_echo "no" >&6; }
18191 fi
18192
18193
18194 test -n "$READELF" && break
18195 done
18196
18197 else
18198 # The variable is set, but is it from the command line or the environment?
18199
18200 # Try to remove the string !READELF! from our list.
18201 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
18202 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18203 # If it failed, the variable was not from the command line. Ignore it,
18204 # but warn the user (except for BASH, which is always set by the calling BASH).
18205 if test "xREADELF" != xBASH; then
18206 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
18207 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
18208 fi
18209 # Try to locate tool using the code snippet
18210 for ac_prog in greadelf readelf
18211 do
18212 # Extract the first word of "$ac_prog", so it can be a program name with args.
18213 set dummy $ac_prog; ac_word=$2
18214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18215 $as_echo_n "checking for $ac_word... " >&6; }
18216 if ${ac_cv_path_READELF+:} false; then :
18217 $as_echo_n "(cached) " >&6
18218 else
18219 case $READELF in
18220 [\\/]* | ?:[\\/]*)
18221 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18222 ;;
18223 *)
18224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18225 for as_dir in $PATH
18226 do
18227 IFS=$as_save_IFS
18228 test -z "$as_dir" && as_dir=.
18229 for ac_exec_ext in '' $ac_executable_extensions; do
18230 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18231 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18232 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18233 break 2
18234 fi
18235 done
18236 done
18237 IFS=$as_save_IFS
18238
18239 ;;
18240 esac
18241 fi
18242 READELF=$ac_cv_path_READELF
18243 if test -n "$READELF"; then
18244 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18245 $as_echo "$READELF" >&6; }
18246 else
18247 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18248 $as_echo "no" >&6; }
18249 fi
18250
18251
18252 test -n "$READELF" && break
18253 done
18254
18255 else
18256 # If it succeeded, then it was overridden by the user. We will use it
18257 # for the tool.
18258
18259 # First remove it from the list of overridden variables, so we can test
18260 # for unknown variables in the end.
18261 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18262
18263 # Check if the provided tool contains a complete path.
18264 tool_specified="$READELF"
18265 tool_basename="${tool_specified##*/}"
18266 if test "x$tool_basename" = "x$tool_specified"; then
18267 # A command without a complete path is provided, search $PATH.
18268 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
18269 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
18270 # Extract the first word of "$tool_basename", so it can be a program name with args.
18271 set dummy $tool_basename; ac_word=$2
18272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18273 $as_echo_n "checking for $ac_word... " >&6; }
18274 if ${ac_cv_path_READELF+:} false; then :
18275 $as_echo_n "(cached) " >&6
18276 else
18277 case $READELF in
18278 [\\/]* | ?:[\\/]*)
18279 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18280 ;;
18281 *)
18282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18283 for as_dir in $PATH
18284 do
18285 IFS=$as_save_IFS
18286 test -z "$as_dir" && as_dir=.
18287 for ac_exec_ext in '' $ac_executable_extensions; do
18288 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18289 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18290 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18291 break 2
18292 fi
18293 done
18294 done
18295 IFS=$as_save_IFS
18296
18297 ;;
18298 esac
18299 fi
18300 READELF=$ac_cv_path_READELF
18301 if test -n "$READELF"; then
18302 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18303 $as_echo "$READELF" >&6; }
18304 else
18305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18306 $as_echo "no" >&6; }
18307 fi
18308
18309
18310 if test "x$READELF" = x; then
18311 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18312 fi
18313 else
18314 # Otherwise we believe it is a complete path. Use it as it is.
18315 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18316 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18318 $as_echo_n "checking for READELF... " >&6; }
18319 if test ! -x "$tool_specified"; then
18320 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18321 $as_echo "not found" >&6; }
18322 as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18323 fi
18324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18325 $as_echo "$tool_specified" >&6; }
18326 fi
18327 fi
18328 fi
18329
18330
18331
18332
18333 # Publish this variable in the help.
18334
18335
18336 if test "x$HG" = x; then
18337 # The variable is not set by user, try to locate tool using the code snippet
18338 for ac_prog in hg
18339 do
18340 # Extract the first word of "$ac_prog", so it can be a program name with args.
18341 set dummy $ac_prog; ac_word=$2
18342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18343 $as_echo_n "checking for $ac_word... " >&6; }
18344 if ${ac_cv_path_HG+:} false; then :
18345 $as_echo_n "(cached) " >&6
18346 else
18347 case $HG in
18348 [\\/]* | ?:[\\/]*)
18349 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18350 ;;
18351 *)
18352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18353 for as_dir in $PATH
18354 do
18355 IFS=$as_save_IFS
18356 test -z "$as_dir" && as_dir=.
18357 for ac_exec_ext in '' $ac_executable_extensions; do
18358 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18359 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18360 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18361 break 2
18362 fi
18363 done
18364 done
18365 IFS=$as_save_IFS
18366
18367 ;;
18368 esac
18369 fi
18370 HG=$ac_cv_path_HG
18371 if test -n "$HG"; then
18372 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18373 $as_echo "$HG" >&6; }
18374 else
18375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18376 $as_echo "no" >&6; }
18377 fi
18378
18379
18380 test -n "$HG" && break
18381 done
18382
18383 else
18384 # The variable is set, but is it from the command line or the environment?
18385
18386 # Try to remove the string !HG! from our list.
18387 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18388 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18389 # If it failed, the variable was not from the command line. Ignore it,
18390 # but warn the user (except for BASH, which is always set by the calling BASH).
18391 if test "xHG" != xBASH; then
18392 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18393 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18394 fi
18395 # Try to locate tool using the code snippet
18396 for ac_prog in hg
18397 do
18398 # Extract the first word of "$ac_prog", so it can be a program name with args.
18399 set dummy $ac_prog; ac_word=$2
18400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18401 $as_echo_n "checking for $ac_word... " >&6; }
18402 if ${ac_cv_path_HG+:} false; then :
18403 $as_echo_n "(cached) " >&6
18404 else
18405 case $HG in
18406 [\\/]* | ?:[\\/]*)
18407 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18408 ;;
18409 *)
18410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18411 for as_dir in $PATH
18412 do
18413 IFS=$as_save_IFS
18414 test -z "$as_dir" && as_dir=.
18415 for ac_exec_ext in '' $ac_executable_extensions; do
18416 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18417 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18418 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18419 break 2
18420 fi
18421 done
18422 done
18423 IFS=$as_save_IFS
18424
18425 ;;
18426 esac
18427 fi
18428 HG=$ac_cv_path_HG
18429 if test -n "$HG"; then
18430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18431 $as_echo "$HG" >&6; }
18432 else
18433 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18434 $as_echo "no" >&6; }
18435 fi
18436
18437
18438 test -n "$HG" && break
18439 done
18440
18441 else
18442 # If it succeeded, then it was overridden by the user. We will use it
18443 # for the tool.
18444
18445 # First remove it from the list of overridden variables, so we can test
18446 # for unknown variables in the end.
18447 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18448
18449 # Check if the provided tool contains a complete path.
18450 tool_specified="$HG"
18451 tool_basename="${tool_specified##*/}"
18452 if test "x$tool_basename" = "x$tool_specified"; then
18453 # A command without a complete path is provided, search $PATH.
18454 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18455 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18456 # Extract the first word of "$tool_basename", so it can be a program name with args.
18457 set dummy $tool_basename; ac_word=$2
18458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18459 $as_echo_n "checking for $ac_word... " >&6; }
18460 if ${ac_cv_path_HG+:} false; then :
18461 $as_echo_n "(cached) " >&6
18462 else
18463 case $HG in
18464 [\\/]* | ?:[\\/]*)
18465 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18466 ;;
18467 *)
18468 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18469 for as_dir in $PATH
18470 do
18471 IFS=$as_save_IFS
18472 test -z "$as_dir" && as_dir=.
18473 for ac_exec_ext in '' $ac_executable_extensions; do
18474 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18475 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18476 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18477 break 2
18478 fi
18479 done
18480 done
18481 IFS=$as_save_IFS
18482
18483 ;;
18484 esac
18485 fi
18486 HG=$ac_cv_path_HG
18487 if test -n "$HG"; then
18488 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18489 $as_echo "$HG" >&6; }
18490 else
18491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18492 $as_echo "no" >&6; }
18493 fi
18494
18495
18496 if test "x$HG" = x; then
18497 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18498 fi
18499 else
18500 # Otherwise we believe it is a complete path. Use it as it is.
18501 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18502 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18504 $as_echo_n "checking for HG... " >&6; }
18505 if test ! -x "$tool_specified"; then
18506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18507 $as_echo "not found" >&6; }
18508 as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18509 fi
18510 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18511 $as_echo "$tool_specified" >&6; }
18512 fi
18513 fi
18514 fi
18515
18516
18517
18518
18519 # Publish this variable in the help.
18520
18521
18522 if test "x$STAT" = x; then
18523 # The variable is not set by user, try to locate tool using the code snippet
18524 for ac_prog in stat
18525 do
18526 # Extract the first word of "$ac_prog", so it can be a program name with args.
18527 set dummy $ac_prog; ac_word=$2
18528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18529 $as_echo_n "checking for $ac_word... " >&6; }
18530 if ${ac_cv_path_STAT+:} false; then :
18531 $as_echo_n "(cached) " >&6
18532 else
18533 case $STAT in
18534 [\\/]* | ?:[\\/]*)
18535 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18536 ;;
18537 *)
18538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18539 for as_dir in $PATH
18540 do
18541 IFS=$as_save_IFS
18542 test -z "$as_dir" && as_dir=.
18543 for ac_exec_ext in '' $ac_executable_extensions; do
18544 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18545 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18546 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18547 break 2
18548 fi
18549 done
18550 done
18551 IFS=$as_save_IFS
18552
18553 ;;
18554 esac
18555 fi
18556 STAT=$ac_cv_path_STAT
18557 if test -n "$STAT"; then
18558 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18559 $as_echo "$STAT" >&6; }
18560 else
18561 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18562 $as_echo "no" >&6; }
18563 fi
18564
18565
18566 test -n "$STAT" && break
18567 done
18568
18569 else
18570 # The variable is set, but is it from the command line or the environment?
18571
18572 # Try to remove the string !STAT! from our list.
18573 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18574 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18575 # If it failed, the variable was not from the command line. Ignore it,
18576 # but warn the user (except for BASH, which is always set by the calling BASH).
18577 if test "xSTAT" != xBASH; then
18578 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18579 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18580 fi
18581 # Try to locate tool using the code snippet
18582 for ac_prog in stat
18583 do
18584 # Extract the first word of "$ac_prog", so it can be a program name with args.
18585 set dummy $ac_prog; ac_word=$2
18586 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18587 $as_echo_n "checking for $ac_word... " >&6; }
18588 if ${ac_cv_path_STAT+:} false; then :
18589 $as_echo_n "(cached) " >&6
18590 else
18591 case $STAT in
18592 [\\/]* | ?:[\\/]*)
18593 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18594 ;;
18595 *)
18596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18597 for as_dir in $PATH
18598 do
18599 IFS=$as_save_IFS
18600 test -z "$as_dir" && as_dir=.
18601 for ac_exec_ext in '' $ac_executable_extensions; do
18602 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18603 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18604 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18605 break 2
18606 fi
18607 done
18608 done
18609 IFS=$as_save_IFS
18610
18611 ;;
18612 esac
18613 fi
18614 STAT=$ac_cv_path_STAT
18615 if test -n "$STAT"; then
18616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18617 $as_echo "$STAT" >&6; }
18618 else
18619 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18620 $as_echo "no" >&6; }
18621 fi
18622
18623
18624 test -n "$STAT" && break
18625 done
18626
18627 else
18628 # If it succeeded, then it was overridden by the user. We will use it
18629 # for the tool.
18630
18631 # First remove it from the list of overridden variables, so we can test
18632 # for unknown variables in the end.
18633 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18634
18635 # Check if the provided tool contains a complete path.
18636 tool_specified="$STAT"
18637 tool_basename="${tool_specified##*/}"
18638 if test "x$tool_basename" = "x$tool_specified"; then
18639 # A command without a complete path is provided, search $PATH.
18640 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18641 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18642 # Extract the first word of "$tool_basename", so it can be a program name with args.
18643 set dummy $tool_basename; ac_word=$2
18644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18645 $as_echo_n "checking for $ac_word... " >&6; }
18646 if ${ac_cv_path_STAT+:} false; then :
18647 $as_echo_n "(cached) " >&6
18648 else
18649 case $STAT in
18650 [\\/]* | ?:[\\/]*)
18651 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18652 ;;
18653 *)
18654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18655 for as_dir in $PATH
18656 do
18657 IFS=$as_save_IFS
18658 test -z "$as_dir" && as_dir=.
18659 for ac_exec_ext in '' $ac_executable_extensions; do
18660 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18661 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18662 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18663 break 2
18664 fi
18665 done
18666 done
18667 IFS=$as_save_IFS
18668
18669 ;;
18670 esac
18671 fi
18672 STAT=$ac_cv_path_STAT
18673 if test -n "$STAT"; then
18674 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18675 $as_echo "$STAT" >&6; }
18676 else
18677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18678 $as_echo "no" >&6; }
18679 fi
18680
18681
18682 if test "x$STAT" = x; then
18683 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18684 fi
18685 else
18686 # Otherwise we believe it is a complete path. Use it as it is.
18687 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18688 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18690 $as_echo_n "checking for STAT... " >&6; }
18691 if test ! -x "$tool_specified"; then
18692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18693 $as_echo "not found" >&6; }
18694 as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18695 fi
18696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18697 $as_echo "$tool_specified" >&6; }
18698 fi
18699 fi
18700 fi
18701
18702
18703
18704
18705 # Publish this variable in the help.
18706
18707
18708 if test "x$TIME" = x; then
18709 # The variable is not set by user, try to locate tool using the code snippet
18710 for ac_prog in time
18711 do
18712 # Extract the first word of "$ac_prog", so it can be a program name with args.
18713 set dummy $ac_prog; ac_word=$2
18714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18715 $as_echo_n "checking for $ac_word... " >&6; }
18716 if ${ac_cv_path_TIME+:} false; then :
18717 $as_echo_n "(cached) " >&6
18718 else
18719 case $TIME in
18720 [\\/]* | ?:[\\/]*)
18721 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18722 ;;
18723 *)
18724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18725 for as_dir in $PATH
18726 do
18727 IFS=$as_save_IFS
18728 test -z "$as_dir" && as_dir=.
18729 for ac_exec_ext in '' $ac_executable_extensions; do
18730 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18731 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18732 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18733 break 2
18734 fi
18735 done
18736 done
18737 IFS=$as_save_IFS
18738
18739 ;;
18740 esac
18741 fi
18742 TIME=$ac_cv_path_TIME
18743 if test -n "$TIME"; then
18744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18745 $as_echo "$TIME" >&6; }
18746 else
18747 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18748 $as_echo "no" >&6; }
18749 fi
18750
18751
18752 test -n "$TIME" && break
18753 done
18754
18755 else
18756 # The variable is set, but is it from the command line or the environment?
18757
18758 # Try to remove the string !TIME! from our list.
18759 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18760 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18761 # If it failed, the variable was not from the command line. Ignore it,
18762 # but warn the user (except for BASH, which is always set by the calling BASH).
18763 if test "xTIME" != xBASH; then
18764 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18765 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18766 fi
18767 # Try to locate tool using the code snippet
18768 for ac_prog in time
18769 do
18770 # Extract the first word of "$ac_prog", so it can be a program name with args.
18771 set dummy $ac_prog; ac_word=$2
18772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18773 $as_echo_n "checking for $ac_word... " >&6; }
18774 if ${ac_cv_path_TIME+:} false; then :
18775 $as_echo_n "(cached) " >&6
18776 else
18777 case $TIME in
18778 [\\/]* | ?:[\\/]*)
18779 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18780 ;;
18781 *)
18782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18783 for as_dir in $PATH
18784 do
18785 IFS=$as_save_IFS
18786 test -z "$as_dir" && as_dir=.
18787 for ac_exec_ext in '' $ac_executable_extensions; do
18788 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18789 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18790 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18791 break 2
18792 fi
18793 done
18794 done
18795 IFS=$as_save_IFS
18796
18797 ;;
18798 esac
18799 fi
18800 TIME=$ac_cv_path_TIME
18801 if test -n "$TIME"; then
18802 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18803 $as_echo "$TIME" >&6; }
18804 else
18805 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18806 $as_echo "no" >&6; }
18807 fi
18808
18809
18810 test -n "$TIME" && break
18811 done
18812
18813 else
18814 # If it succeeded, then it was overridden by the user. We will use it
18815 # for the tool.
18816
18817 # First remove it from the list of overridden variables, so we can test
18818 # for unknown variables in the end.
18819 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18820
18821 # Check if the provided tool contains a complete path.
18822 tool_specified="$TIME"
18823 tool_basename="${tool_specified##*/}"
18824 if test "x$tool_basename" = "x$tool_specified"; then
18825 # A command without a complete path is provided, search $PATH.
18826 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18827 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18828 # Extract the first word of "$tool_basename", so it can be a program name with args.
18829 set dummy $tool_basename; ac_word=$2
18830 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18831 $as_echo_n "checking for $ac_word... " >&6; }
18832 if ${ac_cv_path_TIME+:} false; then :
18833 $as_echo_n "(cached) " >&6
18834 else
18835 case $TIME in
18836 [\\/]* | ?:[\\/]*)
18837 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18838 ;;
18839 *)
18840 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18841 for as_dir in $PATH
18842 do
18843 IFS=$as_save_IFS
18844 test -z "$as_dir" && as_dir=.
18845 for ac_exec_ext in '' $ac_executable_extensions; do
18846 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18847 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18848 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18849 break 2
18850 fi
18851 done
18852 done
18853 IFS=$as_save_IFS
18854
18855 ;;
18856 esac
18857 fi
18858 TIME=$ac_cv_path_TIME
18859 if test -n "$TIME"; then
18860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18861 $as_echo "$TIME" >&6; }
18862 else
18863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18864 $as_echo "no" >&6; }
18865 fi
18866
18867
18868 if test "x$TIME" = x; then
18869 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18870 fi
18871 else
18872 # Otherwise we believe it is a complete path. Use it as it is.
18873 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18874 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18875 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18876 $as_echo_n "checking for TIME... " >&6; }
18877 if test ! -x "$tool_specified"; then
18878 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18879 $as_echo "not found" >&6; }
18880 as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18881 fi
18882 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18883 $as_echo "$tool_specified" >&6; }
18884 fi
18885 fi
18886 fi
18887
18888
18889 # Check if it's GNU time
18890 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18891 if test "x$IS_GNU_TIME" != x; then
18892 IS_GNU_TIME=yes
18893 else
18894 IS_GNU_TIME=no
18895 fi
18896
18897
18898 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18899
18900
18901
18902 # Publish this variable in the help.
18903
18904
18905 if test "x$DSYMUTIL" = x; then
18906 # The variable is not set by user, try to locate tool using the code snippet
18907 for ac_prog in dsymutil
18908 do
18909 # Extract the first word of "$ac_prog", so it can be a program name with args.
18910 set dummy $ac_prog; ac_word=$2
18911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18912 $as_echo_n "checking for $ac_word... " >&6; }
18913 if ${ac_cv_path_DSYMUTIL+:} false; then :
18914 $as_echo_n "(cached) " >&6
18915 else
18916 case $DSYMUTIL in
18917 [\\/]* | ?:[\\/]*)
18918 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18919 ;;
18920 *)
18921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18922 for as_dir in $PATH
18923 do
18924 IFS=$as_save_IFS
18925 test -z "$as_dir" && as_dir=.
18926 for ac_exec_ext in '' $ac_executable_extensions; do
18927 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18928 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18929 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18930 break 2
18931 fi
18932 done
18933 done
18934 IFS=$as_save_IFS
18935
18936 ;;
18937 esac
18938 fi
18939 DSYMUTIL=$ac_cv_path_DSYMUTIL
18940 if test -n "$DSYMUTIL"; then
18941 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18942 $as_echo "$DSYMUTIL" >&6; }
18943 else
18944 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18945 $as_echo "no" >&6; }
18946 fi
18947
18948
18949 test -n "$DSYMUTIL" && break
18950 done
18951
18952 else
18953 # The variable is set, but is it from the command line or the environment?
18954
18955 # Try to remove the string !DSYMUTIL! from our list.
18956 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18957 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18958 # If it failed, the variable was not from the command line. Ignore it,
18959 # but warn the user (except for BASH, which is always set by the calling BASH).
18960 if test "xDSYMUTIL" != xBASH; then
18961 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18962 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18963 fi
18964 # Try to locate tool using the code snippet
18965 for ac_prog in dsymutil
18966 do
18967 # Extract the first word of "$ac_prog", so it can be a program name with args.
18968 set dummy $ac_prog; ac_word=$2
18969 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18970 $as_echo_n "checking for $ac_word... " >&6; }
18971 if ${ac_cv_path_DSYMUTIL+:} false; then :
18972 $as_echo_n "(cached) " >&6
18973 else
18974 case $DSYMUTIL in
18975 [\\/]* | ?:[\\/]*)
18976 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18977 ;;
18978 *)
18979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18980 for as_dir in $PATH
18981 do
18982 IFS=$as_save_IFS
18983 test -z "$as_dir" && as_dir=.
18984 for ac_exec_ext in '' $ac_executable_extensions; do
18985 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18986 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18987 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18988 break 2
18989 fi
18990 done
18991 done
18992 IFS=$as_save_IFS
18993
18994 ;;
18995 esac
18996 fi
18997 DSYMUTIL=$ac_cv_path_DSYMUTIL
18998 if test -n "$DSYMUTIL"; then
18999 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19000 $as_echo "$DSYMUTIL" >&6; }
19001 else
19002 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19003 $as_echo "no" >&6; }
19004 fi
19005
19006
19007 test -n "$DSYMUTIL" && break
19008 done
19009
19010 else
19011 # If it succeeded, then it was overridden by the user. We will use it
19012 # for the tool.
19013
19014 # First remove it from the list of overridden variables, so we can test
19015 # for unknown variables in the end.
19016 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19017
19018 # Check if the provided tool contains a complete path.
19019 tool_specified="$DSYMUTIL"
19020 tool_basename="${tool_specified##*/}"
19021 if test "x$tool_basename" = "x$tool_specified"; then
19022 # A command without a complete path is provided, search $PATH.
19023 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
19024 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
19025 # Extract the first word of "$tool_basename", so it can be a program name with args.
19026 set dummy $tool_basename; ac_word=$2
19027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19028 $as_echo_n "checking for $ac_word... " >&6; }
19029 if ${ac_cv_path_DSYMUTIL+:} false; then :
19030 $as_echo_n "(cached) " >&6
19031 else
19032 case $DSYMUTIL in
19033 [\\/]* | ?:[\\/]*)
19034 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19035 ;;
19036 *)
19037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19038 for as_dir in $PATH
19039 do
19040 IFS=$as_save_IFS
19041 test -z "$as_dir" && as_dir=.
19042 for ac_exec_ext in '' $ac_executable_extensions; do
19043 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19044 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19045 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19046 break 2
19047 fi
19048 done
19049 done
19050 IFS=$as_save_IFS
19051
19052 ;;
19053 esac
19054 fi
19055 DSYMUTIL=$ac_cv_path_DSYMUTIL
19056 if test -n "$DSYMUTIL"; then
19057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19058 $as_echo "$DSYMUTIL" >&6; }
19059 else
19060 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19061 $as_echo "no" >&6; }
19062 fi
19063
19064
19065 if test "x$DSYMUTIL" = x; then
19066 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19067 fi
19068 else
19069 # Otherwise we believe it is a complete path. Use it as it is.
19070 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
19071 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
19072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
19073 $as_echo_n "checking for DSYMUTIL... " >&6; }
19074 if test ! -x "$tool_specified"; then
19075 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19076 $as_echo "not found" >&6; }
19077 as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
19078 fi
19079 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19080 $as_echo "$tool_specified" >&6; }
19081 fi
19082 fi
19083 fi
19084
19085
19086
19087 if test "x$DSYMUTIL" = x; then
19088 as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
19089 fi
19090
19091
19092
19093
19094
19095 # Publish this variable in the help.
19096
19097
19098 if test "x$XATTR" = x; then
19099 # The variable is not set by user, try to locate tool using the code snippet
19100 for ac_prog in xattr
19101 do
19102 # Extract the first word of "$ac_prog", so it can be a program name with args.
19103 set dummy $ac_prog; ac_word=$2
19104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19105 $as_echo_n "checking for $ac_word... " >&6; }
19106 if ${ac_cv_path_XATTR+:} false; then :
19107 $as_echo_n "(cached) " >&6
19108 else
19109 case $XATTR in
19110 [\\/]* | ?:[\\/]*)
19111 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19112 ;;
19113 *)
19114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19115 for as_dir in $PATH
19116 do
19117 IFS=$as_save_IFS
19118 test -z "$as_dir" && as_dir=.
19119 for ac_exec_ext in '' $ac_executable_extensions; do
19120 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19121 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19122 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19123 break 2
19124 fi
19125 done
19126 done
19127 IFS=$as_save_IFS
19128
19129 ;;
19130 esac
19131 fi
19132 XATTR=$ac_cv_path_XATTR
19133 if test -n "$XATTR"; then
19134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19135 $as_echo "$XATTR" >&6; }
19136 else
19137 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19138 $as_echo "no" >&6; }
19139 fi
19140
19141
19142 test -n "$XATTR" && break
19143 done
19144
19145 else
19146 # The variable is set, but is it from the command line or the environment?
19147
19148 # Try to remove the string !XATTR! from our list.
19149 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19150 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19151 # If it failed, the variable was not from the command line. Ignore it,
19152 # but warn the user (except for BASH, which is always set by the calling BASH).
19153 if test "xXATTR" != xBASH; then
19154 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19155 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19156 fi
19157 # Try to locate tool using the code snippet
19158 for ac_prog in xattr
19159 do
19160 # Extract the first word of "$ac_prog", so it can be a program name with args.
19161 set dummy $ac_prog; ac_word=$2
19162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19163 $as_echo_n "checking for $ac_word... " >&6; }
19164 if ${ac_cv_path_XATTR+:} false; then :
19165 $as_echo_n "(cached) " >&6
19166 else
19167 case $XATTR in
19168 [\\/]* | ?:[\\/]*)
19169 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19170 ;;
19171 *)
19172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19173 for as_dir in $PATH
19174 do
19175 IFS=$as_save_IFS
19176 test -z "$as_dir" && as_dir=.
19177 for ac_exec_ext in '' $ac_executable_extensions; do
19178 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19179 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19180 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19181 break 2
19182 fi
19183 done
19184 done
19185 IFS=$as_save_IFS
19186
19187 ;;
19188 esac
19189 fi
19190 XATTR=$ac_cv_path_XATTR
19191 if test -n "$XATTR"; then
19192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19193 $as_echo "$XATTR" >&6; }
19194 else
19195 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19196 $as_echo "no" >&6; }
19197 fi
19198
19199
19200 test -n "$XATTR" && break
19201 done
19202
19203 else
19204 # If it succeeded, then it was overridden by the user. We will use it
19205 # for the tool.
19206
19207 # First remove it from the list of overridden variables, so we can test
19208 # for unknown variables in the end.
19209 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19210
19211 # Check if the provided tool contains a complete path.
19212 tool_specified="$XATTR"
19213 tool_basename="${tool_specified##*/}"
19214 if test "x$tool_basename" = "x$tool_specified"; then
19215 # A command without a complete path is provided, search $PATH.
19216 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19217 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19218 # Extract the first word of "$tool_basename", so it can be a program name with args.
19219 set dummy $tool_basename; ac_word=$2
19220 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19221 $as_echo_n "checking for $ac_word... " >&6; }
19222 if ${ac_cv_path_XATTR+:} false; then :
19223 $as_echo_n "(cached) " >&6
19224 else
19225 case $XATTR in
19226 [\\/]* | ?:[\\/]*)
19227 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19228 ;;
19229 *)
19230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19231 for as_dir in $PATH
19232 do
19233 IFS=$as_save_IFS
19234 test -z "$as_dir" && as_dir=.
19235 for ac_exec_ext in '' $ac_executable_extensions; do
19236 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19237 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19238 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19239 break 2
19240 fi
19241 done
19242 done
19243 IFS=$as_save_IFS
19244
19245 ;;
19246 esac
19247 fi
19248 XATTR=$ac_cv_path_XATTR
19249 if test -n "$XATTR"; then
19250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19251 $as_echo "$XATTR" >&6; }
19252 else
19253 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19254 $as_echo "no" >&6; }
19255 fi
19256
19257
19258 if test "x$XATTR" = x; then
19259 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19260 fi
19261 else
19262 # Otherwise we believe it is a complete path. Use it as it is.
19263 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19264 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19265 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19266 $as_echo_n "checking for XATTR... " >&6; }
19267 if test ! -x "$tool_specified"; then
19268 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19269 $as_echo "not found" >&6; }
19270 as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19271 fi
19272 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19273 $as_echo "$tool_specified" >&6; }
19274 fi
19275 fi
19276 fi
19277
19278
19279
19280 if test "x$XATTR" = x; then
19281 as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19282 fi
19283
19284
19285
19286
19287 # Publish this variable in the help.
19288
19289
19290 if test "x$CODESIGN" = x; then
19291 # The variable is not set by user, try to locate tool using the code snippet
19292 for ac_prog in codesign
19293 do
19294 # Extract the first word of "$ac_prog", so it can be a program name with args.
19295 set dummy $ac_prog; ac_word=$2
19296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19297 $as_echo_n "checking for $ac_word... " >&6; }
19298 if ${ac_cv_path_CODESIGN+:} false; then :
19299 $as_echo_n "(cached) " >&6
19300 else
19301 case $CODESIGN in
19302 [\\/]* | ?:[\\/]*)
19303 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19304 ;;
19305 *)
19306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19307 for as_dir in $PATH
19308 do
19309 IFS=$as_save_IFS
19310 test -z "$as_dir" && as_dir=.
19311 for ac_exec_ext in '' $ac_executable_extensions; do
19312 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19313 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19314 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19315 break 2
19316 fi
19317 done
19318 done
19319 IFS=$as_save_IFS
19320
19321 ;;
19322 esac
19323 fi
19324 CODESIGN=$ac_cv_path_CODESIGN
19325 if test -n "$CODESIGN"; then
19326 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19327 $as_echo "$CODESIGN" >&6; }
19328 else
19329 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19330 $as_echo "no" >&6; }
19331 fi
19332
19333
19334 test -n "$CODESIGN" && break
19335 done
19336
19337 else
19338 # The variable is set, but is it from the command line or the environment?
19339
19340 # Try to remove the string !CODESIGN! from our list.
19341 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19342 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19343 # If it failed, the variable was not from the command line. Ignore it,
19344 # but warn the user (except for BASH, which is always set by the calling BASH).
19345 if test "xCODESIGN" != xBASH; then
19346 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19347 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19348 fi
19349 # Try to locate tool using the code snippet
19350 for ac_prog in codesign
19351 do
19352 # Extract the first word of "$ac_prog", so it can be a program name with args.
19353 set dummy $ac_prog; ac_word=$2
19354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19355 $as_echo_n "checking for $ac_word... " >&6; }
19356 if ${ac_cv_path_CODESIGN+:} false; then :
19357 $as_echo_n "(cached) " >&6
19358 else
19359 case $CODESIGN in
19360 [\\/]* | ?:[\\/]*)
19361 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19362 ;;
19363 *)
19364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19365 for as_dir in $PATH
19366 do
19367 IFS=$as_save_IFS
19368 test -z "$as_dir" && as_dir=.
19369 for ac_exec_ext in '' $ac_executable_extensions; do
19370 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19371 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19372 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19373 break 2
19374 fi
19375 done
19376 done
19377 IFS=$as_save_IFS
19378
19379 ;;
19380 esac
19381 fi
19382 CODESIGN=$ac_cv_path_CODESIGN
19383 if test -n "$CODESIGN"; then
19384 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19385 $as_echo "$CODESIGN" >&6; }
19386 else
19387 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19388 $as_echo "no" >&6; }
19389 fi
19390
19391
19392 test -n "$CODESIGN" && break
19393 done
19394
19395 else
19396 # If it succeeded, then it was overridden by the user. We will use it
19397 # for the tool.
19398
19399 # First remove it from the list of overridden variables, so we can test
19400 # for unknown variables in the end.
19401 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19402
19403 # Check if the provided tool contains a complete path.
19404 tool_specified="$CODESIGN"
19405 tool_basename="${tool_specified##*/}"
19406 if test "x$tool_basename" = "x$tool_specified"; then
19407 # A command without a complete path is provided, search $PATH.
19408 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19409 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19410 # Extract the first word of "$tool_basename", so it can be a program name with args.
19411 set dummy $tool_basename; ac_word=$2
19412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19413 $as_echo_n "checking for $ac_word... " >&6; }
19414 if ${ac_cv_path_CODESIGN+:} false; then :
19415 $as_echo_n "(cached) " >&6
19416 else
19417 case $CODESIGN in
19418 [\\/]* | ?:[\\/]*)
19419 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19420 ;;
19421 *)
19422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19423 for as_dir in $PATH
19424 do
19425 IFS=$as_save_IFS
19426 test -z "$as_dir" && as_dir=.
19427 for ac_exec_ext in '' $ac_executable_extensions; do
19428 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19429 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19430 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19431 break 2
19432 fi
19433 done
19434 done
19435 IFS=$as_save_IFS
19436
19437 ;;
19438 esac
19439 fi
19440 CODESIGN=$ac_cv_path_CODESIGN
19441 if test -n "$CODESIGN"; then
19442 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19443 $as_echo "$CODESIGN" >&6; }
19444 else
19445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19446 $as_echo "no" >&6; }
19447 fi
19448
19449
19450 if test "x$CODESIGN" = x; then
19451 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19452 fi
19453 else
19454 # Otherwise we believe it is a complete path. Use it as it is.
19455 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19456 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19457 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19458 $as_echo_n "checking for CODESIGN... " >&6; }
19459 if test ! -x "$tool_specified"; then
19460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19461 $as_echo "not found" >&6; }
19462 as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19463 fi
19464 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19465 $as_echo "$tool_specified" >&6; }
19466 fi
19467 fi
19468 fi
19469
19470
19471 if test "x$CODESIGN" != "x"; then
19472 # Verify that the openjdk_codesign certificate is present
19473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19474 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19475 rm -f codesign-testfile
19476 touch codesign-testfile
19477 codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19478 rm -f codesign-testfile
19479 if test "x$CODESIGN" = x; then
19480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19481 $as_echo "no" >&6; }
19482 else
19483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19484 $as_echo "yes" >&6; }
19485 fi
19486 fi
19487 fi
19488
19489
19490 # Test if bash supports pipefail.
19491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
19492 $as_echo_n "checking if bash supports pipefail... " >&6; }
19493 if ${BASH} -c 'set -o pipefail'; then
19494 BASH_ARGS="$BASH_ARGS -o pipefail"
19495 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19496 $as_echo "yes" >&6; }
19497 else
19498 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19499 $as_echo "no" >&6; }
19500 fi
19501
19502 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
19503 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
19504 if ${BASH} -e -c 'true'; then
19505 BASH_ARGS="$BASH_ARGS -e"
19506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19507 $as_echo "yes" >&6; }
19508 else
19509 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19510 $as_echo "no" >&6; }
19511 fi
19512
19513
19514
19515
19516 # Check if pkg-config is available.
19517
19518
19519 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19520 if test -n "$ac_tool_prefix"; then
19521 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19522 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19524 $as_echo_n "checking for $ac_word... " >&6; }
19525 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19526 $as_echo_n "(cached) " >&6
19527 else
19528 case $PKG_CONFIG in
19529 [\\/]* | ?:[\\/]*)
19530 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19531 ;;
19532 *)
19533 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19534 for as_dir in $PATH
19535 do
19536 IFS=$as_save_IFS
19537 test -z "$as_dir" && as_dir=.
19538 for ac_exec_ext in '' $ac_executable_extensions; do
19539 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19540 ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19541 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19542 break 2
19543 fi
19544 done
19545 done
19546 IFS=$as_save_IFS
19547
19548 ;;
19549 esac
19550 fi
19551 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19552 if test -n "$PKG_CONFIG"; then
19553 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19554 $as_echo "$PKG_CONFIG" >&6; }
19555 else
19556 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19557 $as_echo "no" >&6; }
19558 fi
19559
19560
19561 fi
19562 if test -z "$ac_cv_path_PKG_CONFIG"; then
19563 ac_pt_PKG_CONFIG=$PKG_CONFIG
19564 # Extract the first word of "pkg-config", so it can be a program name with args.
19565 set dummy pkg-config; ac_word=$2
19566 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19567 $as_echo_n "checking for $ac_word... " >&6; }
19568 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19569 $as_echo_n "(cached) " >&6
19570 else
19571 case $ac_pt_PKG_CONFIG in
19572 [\\/]* | ?:[\\/]*)
19573 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19574 ;;
19575 *)
19576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19577 for as_dir in $PATH
19578 do
19579 IFS=$as_save_IFS
19580 test -z "$as_dir" && as_dir=.
19581 for ac_exec_ext in '' $ac_executable_extensions; do
19582 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19583 ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19584 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19585 break 2
19586 fi
19587 done
19588 done
19589 IFS=$as_save_IFS
19590
19591 ;;
19592 esac
19593 fi
19594 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19595 if test -n "$ac_pt_PKG_CONFIG"; then
19596 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19597 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19598 else
19599 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19600 $as_echo "no" >&6; }
19601 fi
19602
19603 if test "x$ac_pt_PKG_CONFIG" = x; then
19604 PKG_CONFIG=""
19605 else
19606 case $cross_compiling:$ac_tool_warned in
19607 yes:)
19608 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19609 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19610 ac_tool_warned=yes ;;
19611 esac
19612 PKG_CONFIG=$ac_pt_PKG_CONFIG
19613 fi
19614 else
19615 PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19616 fi
19617
19618 fi
19619 if test -n "$PKG_CONFIG"; then
19620 _pkg_min_version=0.9.0
19621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19622 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19623 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19624 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19625 $as_echo "yes" >&6; }
19626 else
19627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19628 $as_echo "no" >&6; }
19629 PKG_CONFIG=""
19630 fi
19631
19632 fi
19633
19634 # After basic tools have been setup, we can check build os specific details.
19635
19636 ###############################################################################
19637
19638 # Note that this is the build platform OS version!
19639
19640 OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19641 OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19642 OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19643 OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19644
19645
19646
19647
19648
19649 # Setup builddeps, for automatic downloading of tools we need.
19650 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19651 # boot-jdk setup, but we need to have basic tools setup first.
19652
19653
19654 # Check whether --with-builddeps-conf was given.
19655 if test "${with_builddeps_conf+set}" = set; then :
19656 withval=$with_builddeps_conf;
19657 fi
19658
19659
19660
19661 # Check whether --with-builddeps-server was given.
19662 if test "${with_builddeps_server+set}" = set; then :
19663 withval=$with_builddeps_server;
19664 fi
19665
19666
19667
19668 # Check whether --with-builddeps-dir was given.
19669 if test "${with_builddeps_dir+set}" = set; then :
19670 withval=$with_builddeps_dir;
19671 else
19672 with_builddeps_dir=/localhome/builddeps
19673 fi
19674
19675
19676
19677 # Check whether --with-builddeps-group was given.
19678 if test "${with_builddeps_group+set}" = set; then :
19679 withval=$with_builddeps_group;
19680 fi
19681
19682
19683
19684
19685 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19686 if test "x$with_builddeps_conf" != x; then
19687 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19688 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19689 builddepsfile=$with_builddeps_conf
19690 if test -s $builddepsfile; then
19691 . $builddepsfile
19692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19693 $as_echo "loaded!" >&6; }
19694 else
19695 as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19696 fi
19697 else
19698 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19699 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19700 builddepsfile=`mktemp`
19701 touch $builddepsfile
19702 # Put all found confs into a single file.
19703 find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19704 # Source the file to acquire the variables
19705 if test -s $builddepsfile; then
19706 . $builddepsfile
19707 { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19708 $as_echo "found at least one!" >&6; }
19709 else
19710 as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19711 fi
19712 fi
19713 # Create build and target names that use _ instead of "-" and ".".
19714 # This is necessary to use them in variable names.
19715 build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19716 target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19717 # Extract rewrite information for build and target
19718 eval rewritten_build=\${REWRITE_${build_var}}
19719 if test "x$rewritten_build" = x; then
19720 rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19721 echo Build stays the same $rewritten_build
19722 else
19723 echo Rewriting build for builddeps into $rewritten_build
19724 fi
19725 eval rewritten_target=\${REWRITE_${target_var}}
19726 if test "x$rewritten_target" = x; then
19727 rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19728 echo Target stays the same $rewritten_target
19729 else
19730 echo Rewriting target for builddeps into $rewritten_target
19731 fi
19732 rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19733 rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19734 fi
19735 for ac_prog in 7z unzip
19736 do
19737 # Extract the first word of "$ac_prog", so it can be a program name with args.
19738 set dummy $ac_prog; ac_word=$2
19739 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19740 $as_echo_n "checking for $ac_word... " >&6; }
19741 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19742 $as_echo_n "(cached) " >&6
19743 else
19744 if test -n "$BDEPS_UNZIP"; then
19745 ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19746 else
19747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19748 for as_dir in $PATH
19749 do
19750 IFS=$as_save_IFS
19751 test -z "$as_dir" && as_dir=.
19752 for ac_exec_ext in '' $ac_executable_extensions; do
19753 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19754 ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19755 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19756 break 2
19757 fi
19758 done
19759 done
19760 IFS=$as_save_IFS
19761
19762 fi
19763 fi
19764 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19765 if test -n "$BDEPS_UNZIP"; then
19766 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19767 $as_echo "$BDEPS_UNZIP" >&6; }
19768 else
19769 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19770 $as_echo "no" >&6; }
19771 fi
19772
19773
19774 test -n "$BDEPS_UNZIP" && break
19775 done
19776
19777 if test "x$BDEPS_UNZIP" = x7z; then
19778 BDEPS_UNZIP="7z x"
19779 fi
19780
19781 for ac_prog in wget lftp ftp
19782 do
19783 # Extract the first word of "$ac_prog", so it can be a program name with args.
19784 set dummy $ac_prog; ac_word=$2
19785 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19786 $as_echo_n "checking for $ac_word... " >&6; }
19787 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19788 $as_echo_n "(cached) " >&6
19789 else
19790 if test -n "$BDEPS_FTP"; then
19791 ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19792 else
19793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19794 for as_dir in $PATH
19795 do
19796 IFS=$as_save_IFS
19797 test -z "$as_dir" && as_dir=.
19798 for ac_exec_ext in '' $ac_executable_extensions; do
19799 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19800 ac_cv_prog_BDEPS_FTP="$ac_prog"
19801 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19802 break 2
19803 fi
19804 done
19805 done
19806 IFS=$as_save_IFS
19807
19808 fi
19809 fi
19810 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19811 if test -n "$BDEPS_FTP"; then
19812 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19813 $as_echo "$BDEPS_FTP" >&6; }
19814 else
19815 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19816 $as_echo "no" >&6; }
19817 fi
19818
19819
19820 test -n "$BDEPS_FTP" && break
19821 done
19822
19823
19824
19825 ###############################################################################
19826 #
19827 # Determine OpenJDK variants, options and version numbers.
19828 #
19829 ###############################################################################
19830
19831 # We need build & target for this.
19832
19833
19834 ###############################################################################
19835 #
19836 # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19837 # We always build headless support.
19838 #
19839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19840 $as_echo_n "checking headful support... " >&6; }
19841 # Check whether --enable-headful was given.
19842 if test "${enable_headful+set}" = set; then :
19843 enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19844 else
19845 SUPPORT_HEADFUL=yes
19846 fi
19847
19848
19849 SUPPORT_HEADLESS=yes
19850 BUILD_HEADLESS="BUILD_HEADLESS:=true"
19851
19852 if test "x$SUPPORT_HEADFUL" = xyes; then
19853 # We are building both headful and headless.
19854 headful_msg="include support for both headful and headless"
19855 fi
19856
19857 if test "x$SUPPORT_HEADFUL" = xno; then
19858 # Thus we are building headless only.
19859 BUILD_HEADLESS="BUILD_HEADLESS:=true"
19860 headful_msg="headless only"
19861 fi
19862
19863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19864 $as_echo "$headful_msg" >&6; }
19865
19866
19867
19868
19869
19870 # Control wether Hotspot runs Queens test after build.
19871 # Check whether --enable-hotspot-test-in-build was given.
19872 if test "${enable_hotspot_test_in_build+set}" = set; then :
19873 enableval=$enable_hotspot_test_in_build;
19874 else
19875 enable_hotspot_test_in_build=no
19876 fi
19877
19878 if test "x$enable_hotspot_test_in_build" = "xyes"; then
19879 TEST_IN_BUILD=true
19880 else
19881 TEST_IN_BUILD=false
19882 fi
19883
19884
19885 ###############################################################################
19886 #
19887 # Choose cacerts source file
19888 #
19889
19890 # Check whether --with-cacerts-file was given.
19891 if test "${with_cacerts_file+set}" = set; then :
19892 withval=$with_cacerts_file;
19893 fi
19894
19895 if test "x$with_cacerts_file" != x; then
19896 CACERTS_FILE=$with_cacerts_file
19897 fi
19898
19899
19900 ###############################################################################
19901 #
19902 # Enable or disable unlimited crypto
19903 #
19904 # Check whether --enable-unlimited-crypto was given.
19905 if test "${enable_unlimited_crypto+set}" = set; then :
19906 enableval=$enable_unlimited_crypto;
19907 else
19908 enable_unlimited_crypto=no
19909 fi
19910
19911 if test "x$enable_unlimited_crypto" = "xyes"; then
19912 UNLIMITED_CRYPTO=true
19913 else
19914 UNLIMITED_CRYPTO=false
19915 fi
19916
19917
19918 ###############################################################################
19919 #
19920 # Enable or disable the elliptic curve crypto implementation
19921 #
19922
19923
19924 ###############################################################################
19925 #
19926 # --enable-rmiconnector-iiop
19927 #
19928 # Check whether --enable-rmiconnector-iiop was given.
19929 if test "${enable_rmiconnector_iiop+set}" = set; then :
19930 enableval=$enable_rmiconnector_iiop;
19931 fi
19932
19933 if test "x$enable_rmiconnector_iiop" = "xyes"; then
19934 RMICONNECTOR_IIOP=true
19935 else
19936 RMICONNECTOR_IIOP=false
19937 fi
19938
19939
19940 ###############################################################################
19941 #
19942 # Compress jars
19943 #
19944 COMPRESS_JARS=false
19945
19946
19947
19948
19949 # Source the version numbers
19950 . $AUTOCONF_DIR/version-numbers
19951
19952 # Get the settings from parameters
19953
19954 # Check whether --with-milestone was given.
19955 if test "${with_milestone+set}" = set; then :
19956 withval=$with_milestone;
19957 fi
19958
19959 if test "x$with_milestone" = xyes; then
19960 as_fn_error $? "Milestone must have a value" "$LINENO" 5
19961 elif test "x$with_milestone" != x; then
19962 MILESTONE="$with_milestone"
19963 fi
19964 if test "x$MILESTONE" = x; then
19965 MILESTONE=internal
19966 fi
19967
19968
19969 # Check whether --with-update-version was given.
19970 if test "${with_update_version+set}" = set; then :
19971 withval=$with_update_version;
19972 fi
19973
19974 if test "x$with_update_version" = xyes; then
19975 as_fn_error $? "Update version must have a value" "$LINENO" 5
19976 elif test "x$with_update_version" != x; then
19977 JDK_UPDATE_VERSION="$with_update_version"
19978 # On macosx 10.7, it's not possible to set --with-update-version=0X due
19979 # to a bug in expr (which reduces it to just X). To work around this, we
19980 # always add a 0 to one digit update versions.
19981 if test "${#JDK_UPDATE_VERSION}" = "1"; then
19982 JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19983 fi
19984 fi
19985
19986
19987 # Check whether --with-user-release-suffix was given.
19988 if test "${with_user_release_suffix+set}" = set; then :
19989 withval=$with_user_release_suffix;
19990 fi
19991
19992 if test "x$with_user_release_suffix" = xyes; then
19993 as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19994 elif test "x$with_user_release_suffix" != x; then
19995 USER_RELEASE_SUFFIX="$with_user_release_suffix"
19996 fi
19997
19998
19999 # Check whether --with-build-number was given.
20000 if test "${with_build_number+set}" = set; then :
20001 withval=$with_build_number;
20002 fi
20003
20004 if test "x$with_build_number" = xyes; then
20005 as_fn_error $? "Build number must have a value" "$LINENO" 5
20006 elif test "x$with_build_number" != x; then
20007 JDK_BUILD_NUMBER="$with_build_number"
20008 fi
20009 # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
20010 if test "x$JDK_BUILD_NUMBER" = x; then
20011 JDK_BUILD_NUMBER=b00
20012 if test "x$USER_RELEASE_SUFFIX" = x; then
20013 BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
20014 # Avoid [:alnum:] since it depends on the locale.
20015 CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
20016 USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20017 fi
20018 fi
20019
20020 # Now set the JDK version, milestone, build number etc.
20021
20022
20023
20024
20025
20026
20027
20028
20029
20030
20031
20032
20033
20034
20035
20036
20037 # Check whether --with-copyright-year was given.
20038 if test "${with_copyright_year+set}" = set; then :
20039 withval=$with_copyright_year;
20040 fi
20041
20042 if test "x$with_copyright_year" = xyes; then
20043 as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20044 elif test "x$with_copyright_year" != x; then
20045 COPYRIGHT_YEAR="$with_copyright_year"
20046 else
20047 COPYRIGHT_YEAR=`date +'%Y'`
20048 fi
20049
20050
20051 if test "x$JDK_UPDATE_VERSION" != x; then
20052 JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
20053 else
20054 JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
20055 fi
20056
20057
20058 COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
20059
20060
20061
20062 ###############################################################################
20063 #
20064 # Setup BootJDK, used to bootstrap the build.
20065 #
20066 ###############################################################################
20067
20068
20069 BOOT_JDK_FOUND=no
20070
20071 # Check whether --with-boot-jdk was given.
20072 if test "${with_boot_jdk+set}" = set; then :
20073 withval=$with_boot_jdk;
20074 fi
20075
20076
20077 # We look for the Boot JDK through various means, going from more certain to
20078 # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20079 # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20080 # must check if this is indeed valid; otherwise we'll continue looking.
20081
20082 # Test: Is bootjdk explicitely set by command line arguments?
20083
20084 if test "x$BOOT_JDK_FOUND" = xno; then
20085 # Now execute the test
20086
20087 if test "x$with_boot_jdk" != x; then
20088 BOOT_JDK=$with_boot_jdk
20089 BOOT_JDK_FOUND=maybe
20090 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20091 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20092 fi
20093
20094
20095 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20096 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20097 # Do we have a bin/java?
20098 if test ! -x "$BOOT_JDK/bin/java"; then
20099 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20100 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20101 BOOT_JDK_FOUND=no
20102 else
20103 # Do we have a bin/javac?
20104 if test ! -x "$BOOT_JDK/bin/javac"; then
20105 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20106 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20107 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20108 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20109 BOOT_JDK_FOUND=no
20110 else
20111 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20112 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20113
20114 # Extra M4 quote needed to protect [] in grep expression.
20115 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20116 if test "x$FOUND_CORRECT_VERSION" = x; then
20117 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20118 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20119 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20120 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20121 BOOT_JDK_FOUND=no
20122 else
20123 # We're done! :-)
20124 BOOT_JDK_FOUND=yes
20125
20126 # Only process if variable expands to non-empty
20127
20128 if test "x$BOOT_JDK" != x; then
20129 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20130
20131 # Input might be given as Windows format, start by converting to
20132 # unix format.
20133 path="$BOOT_JDK"
20134 new_path=`$CYGPATH -u "$path"`
20135
20136 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20137 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20138 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20139 # "foo.exe" is OK but "foo" is an error.
20140 #
20141 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20142 # It is also a way to make sure we got the proper file name for the real test later on.
20143 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20144 if test "x$test_shortpath" = x; then
20145 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20146 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20147 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20148 fi
20149
20150 # Call helper function which possibly converts this using DOS-style short mode.
20151 # If so, the updated path is stored in $new_path.
20152
20153 input_path="$new_path"
20154 # Check if we need to convert this using DOS-style short mode. If the path
20155 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20156 # take no chances and rewrite it.
20157 # Note: m4 eats our [], so we need to use [ and ] instead.
20158 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20159 if test "x$has_forbidden_chars" != x; then
20160 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20161 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20162 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20163 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20164 # Going to short mode and back again did indeed matter. Since short mode is
20165 # case insensitive, let's make it lowercase to improve readability.
20166 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20167 # Now convert it back to Unix-stile (cygpath)
20168 input_path=`$CYGPATH -u "$shortmode_path"`
20169 new_path="$input_path"
20170 fi
20171 fi
20172
20173 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20174 if test "x$test_cygdrive_prefix" = x; then
20175 # As a simple fix, exclude /usr/bin since it's not a real path.
20176 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20177 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20178 # a path prefixed by /cygdrive for fixpath to work.
20179 new_path="$CYGWIN_ROOT_PATH$input_path"
20180 fi
20181 fi
20182
20183
20184 if test "x$path" != "x$new_path"; then
20185 BOOT_JDK="$new_path"
20186 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20187 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20188 fi
20189
20190 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20191
20192 path="$BOOT_JDK"
20193 has_colon=`$ECHO $path | $GREP ^.:`
20194 new_path="$path"
20195 if test "x$has_colon" = x; then
20196 # Not in mixed or Windows style, start by that.
20197 new_path=`cmd //c echo $path`
20198 fi
20199
20200
20201 input_path="$new_path"
20202 # Check if we need to convert this using DOS-style short mode. If the path
20203 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20204 # take no chances and rewrite it.
20205 # Note: m4 eats our [], so we need to use [ and ] instead.
20206 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20207 if test "x$has_forbidden_chars" != x; then
20208 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20209 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20210 fi
20211
20212
20213 windows_path="$new_path"
20214 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20215 unix_path=`$CYGPATH -u "$windows_path"`
20216 new_path="$unix_path"
20217 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20218 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20219 new_path="$unix_path"
20220 fi
20221
20222 if test "x$path" != "x$new_path"; then
20223 BOOT_JDK="$new_path"
20224 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20225 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20226 fi
20227
20228 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20229 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20230
20231 else
20232 # We're on a unix platform. Hooray! :)
20233 path="$BOOT_JDK"
20234 has_space=`$ECHO "$path" | $GREP " "`
20235 if test "x$has_space" != x; then
20236 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20237 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20238 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20239 fi
20240
20241 # Use eval to expand a potential ~
20242 eval path="$path"
20243 if test ! -f "$path" && test ! -d "$path"; then
20244 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20245 fi
20246
20247 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20248 fi
20249 fi
20250
20251 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20252 $as_echo_n "checking for Boot JDK... " >&6; }
20253 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20254 $as_echo "$BOOT_JDK" >&6; }
20255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20256 $as_echo_n "checking Boot JDK version... " >&6; }
20257 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20258 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20259 $as_echo "$BOOT_JDK_VERSION" >&6; }
20260 fi # end check jdk version
20261 fi # end check javac
20262 fi # end check java
20263 fi # end check boot jdk found
20264 fi
20265
20266 if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20267 # Having specified an argument which is incorrect will produce an instant failure;
20268 # we should not go on looking
20269 as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20270 fi
20271
20272 # Test: Is bootjdk available from builddeps?
20273
20274 if test "x$BOOT_JDK_FOUND" = xno; then
20275 # Now execute the test
20276
20277
20278
20279 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20280 # Source the builddeps file again, to make sure it uses the latest variables!
20281 . $builddepsfile
20282 # Look for a target and build machine specific resource!
20283 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20284 if test "x$resource" = x; then
20285 # Ok, lets instead look for a target specific resource
20286 eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20287 fi
20288 if test "x$resource" = x; then
20289 # Ok, lets instead look for a build specific resource
20290 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20291 fi
20292 if test "x$resource" = x; then
20293 # Ok, lets instead look for a generic resource
20294 # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20295 resource=${builddep_bootjdk}
20296 fi
20297 if test "x$resource" != x; then
20298 { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20299 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20300 # If the resource in the builddeps.conf file is an existing directory,
20301 # for example /java/linux/cups
20302 if test -d ${resource}; then
20303 depdir=${resource}
20304 else
20305
20306 # bootjdk is for example mymodule
20307 # $resource is for example libs/general/libmymod_1_2_3.zip
20308 # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20309 # $with_builddeps_dir is for example /localhome/builddeps
20310 # depdir is the name of the variable into which we store the depdir, eg MYMOD
20311 # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20312 # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20313 filename=`basename $resource`
20314 filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20315 filebase=${filename%%.*}
20316 extension=${filename#*.}
20317 installdir=$with_builddeps_dir/$filebase
20318 if test ! -f $installdir/$filename.unpacked; then
20319 { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20320 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20321 if test ! -d $installdir; then
20322 mkdir -p $installdir
20323 fi
20324 if test ! -d $installdir; then
20325 as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20326 fi
20327 tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20328 touch $tmpfile
20329 if test ! -f $tmpfile; then
20330 as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20331 fi
20332
20333 # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip
20334 # $tmpfile is the local file name for the downloaded file.
20335 VALID_TOOL=no
20336 if test "x$BDEPS_FTP" = xwget; then
20337 VALID_TOOL=yes
20338 wget -O $tmpfile $with_builddeps_server/$resource
20339 fi
20340 if test "x$BDEPS_FTP" = xlftp; then
20341 VALID_TOOL=yes
20342 lftp -c "get $with_builddeps_server/$resource -o $tmpfile"
20343 fi
20344 if test "x$BDEPS_FTP" = xftp; then
20345 VALID_TOOL=yes
20346 FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'`
20347 FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'`
20348 FTPUSERPWD=${FTPSERVER%%@*}
20349 if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20350 FTPUSER=${userpwd%%:*}
20351 FTPPWD=${userpwd#*@}
20352 FTPSERVER=${FTPSERVER#*@}
20353 else
20354 FTPUSER=ftp
20355 FTPPWD=ftp
20356 fi
20357 # the "pass" command does not work on some
20358 # ftp clients (read ftp.exe) but if it works,
20359 # passive mode is better!
20360 ( \
20361 echo "user $FTPUSER $FTPPWD" ; \
20362 echo "pass" ; \
20363 echo "bin" ; \
20364 echo "get $FTPPATH $tmpfile" ; \
20365 ) | ftp -in $FTPSERVER
20366 fi
20367 if test "x$VALID_TOOL" != xyes; then
20368 as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20369 fi
20370
20371 mv $tmpfile $installdir/$filename
20372 if test ! -s $installdir/$filename; then
20373 as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20374 fi
20375 case "$extension" in
20376 zip) echo "Unzipping $installdir/$filename..."
20377 (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20378 ;;
20379 tar.gz) echo "Untaring $installdir/$filename..."
20380 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20381 ;;
20382 tgz) echo "Untaring $installdir/$filename..."
20383 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20384 ;;
20385 *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20386 ;;
20387 esac
20388 fi
20389 if test -f $installdir/$filename.unpacked; then
20390 depdir=$installdir
20391 fi
20392
20393 fi
20394 # Source the builddeps file again, because in the previous command, the depdir
20395 # was updated to point at the current build dependency install directory.
20396 . $builddepsfile
20397 # Now extract variables from the builddeps.conf files.
20398 theroot=${builddep_bootjdk_ROOT}
20399 thecflags=${builddep_bootjdk_CFLAGS}
20400 thelibs=${builddep_bootjdk_LIBS}
20401 if test "x$depdir" = x; then
20402 as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20403 fi
20404 BOOT_JDK=$depdir
20405 if test "x$theroot" != x; then
20406 BOOT_JDK="$theroot"
20407 fi
20408 if test "x$thecflags" != x; then
20409 BOOT_JDK_CFLAGS="$thecflags"
20410 fi
20411 if test "x$thelibs" != x; then
20412 BOOT_JDK_LIBS="$thelibs"
20413 fi
20414 BOOT_JDK_FOUND=maybe
20415 else BOOT_JDK_FOUND=no
20416
20417 fi
20418 else BOOT_JDK_FOUND=no
20419
20420 fi
20421
20422
20423
20424 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20425 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20426 # Do we have a bin/java?
20427 if test ! -x "$BOOT_JDK/bin/java"; then
20428 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20430 BOOT_JDK_FOUND=no
20431 else
20432 # Do we have a bin/javac?
20433 if test ! -x "$BOOT_JDK/bin/javac"; then
20434 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20435 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20436 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20437 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20438 BOOT_JDK_FOUND=no
20439 else
20440 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20441 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20442
20443 # Extra M4 quote needed to protect [] in grep expression.
20444 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20445 if test "x$FOUND_CORRECT_VERSION" = x; then
20446 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20447 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20448 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20449 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20450 BOOT_JDK_FOUND=no
20451 else
20452 # We're done! :-)
20453 BOOT_JDK_FOUND=yes
20454
20455 # Only process if variable expands to non-empty
20456
20457 if test "x$BOOT_JDK" != x; then
20458 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20459
20460 # Input might be given as Windows format, start by converting to
20461 # unix format.
20462 path="$BOOT_JDK"
20463 new_path=`$CYGPATH -u "$path"`
20464
20465 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20466 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20467 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20468 # "foo.exe" is OK but "foo" is an error.
20469 #
20470 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20471 # It is also a way to make sure we got the proper file name for the real test later on.
20472 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20473 if test "x$test_shortpath" = x; then
20474 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20475 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20476 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20477 fi
20478
20479 # Call helper function which possibly converts this using DOS-style short mode.
20480 # If so, the updated path is stored in $new_path.
20481
20482 input_path="$new_path"
20483 # Check if we need to convert this using DOS-style short mode. If the path
20484 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20485 # take no chances and rewrite it.
20486 # Note: m4 eats our [], so we need to use [ and ] instead.
20487 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20488 if test "x$has_forbidden_chars" != x; then
20489 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20490 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20491 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20492 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20493 # Going to short mode and back again did indeed matter. Since short mode is
20494 # case insensitive, let's make it lowercase to improve readability.
20495 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20496 # Now convert it back to Unix-stile (cygpath)
20497 input_path=`$CYGPATH -u "$shortmode_path"`
20498 new_path="$input_path"
20499 fi
20500 fi
20501
20502 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20503 if test "x$test_cygdrive_prefix" = x; then
20504 # As a simple fix, exclude /usr/bin since it's not a real path.
20505 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20506 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20507 # a path prefixed by /cygdrive for fixpath to work.
20508 new_path="$CYGWIN_ROOT_PATH$input_path"
20509 fi
20510 fi
20511
20512
20513 if test "x$path" != "x$new_path"; then
20514 BOOT_JDK="$new_path"
20515 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20516 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20517 fi
20518
20519 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20520
20521 path="$BOOT_JDK"
20522 has_colon=`$ECHO $path | $GREP ^.:`
20523 new_path="$path"
20524 if test "x$has_colon" = x; then
20525 # Not in mixed or Windows style, start by that.
20526 new_path=`cmd //c echo $path`
20527 fi
20528
20529
20530 input_path="$new_path"
20531 # Check if we need to convert this using DOS-style short mode. If the path
20532 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20533 # take no chances and rewrite it.
20534 # Note: m4 eats our [], so we need to use [ and ] instead.
20535 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20536 if test "x$has_forbidden_chars" != x; then
20537 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20538 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20539 fi
20540
20541
20542 windows_path="$new_path"
20543 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20544 unix_path=`$CYGPATH -u "$windows_path"`
20545 new_path="$unix_path"
20546 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20547 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20548 new_path="$unix_path"
20549 fi
20550
20551 if test "x$path" != "x$new_path"; then
20552 BOOT_JDK="$new_path"
20553 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20554 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20555 fi
20556
20557 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20558 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20559
20560 else
20561 # We're on a unix platform. Hooray! :)
20562 path="$BOOT_JDK"
20563 has_space=`$ECHO "$path" | $GREP " "`
20564 if test "x$has_space" != x; then
20565 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20566 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20567 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20568 fi
20569
20570 # Use eval to expand a potential ~
20571 eval path="$path"
20572 if test ! -f "$path" && test ! -d "$path"; then
20573 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20574 fi
20575
20576 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20577 fi
20578 fi
20579
20580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20581 $as_echo_n "checking for Boot JDK... " >&6; }
20582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20583 $as_echo "$BOOT_JDK" >&6; }
20584 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20585 $as_echo_n "checking Boot JDK version... " >&6; }
20586 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20587 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20588 $as_echo "$BOOT_JDK_VERSION" >&6; }
20589 fi # end check jdk version
20590 fi # end check javac
20591 fi # end check java
20592 fi # end check boot jdk found
20593 fi
20594
20595
20596 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20597
20598 if test "x$BOOT_JDK_FOUND" = xno; then
20599 # Now execute the test
20600
20601 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20602 # First check at user selected default
20603
20604 if test "x$BOOT_JDK_FOUND" = xno; then
20605 # Now execute the test
20606
20607 if test -x /usr/libexec/java_home; then
20608 BOOT_JDK=`/usr/libexec/java_home `
20609 BOOT_JDK_FOUND=maybe
20610 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20611 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20612 fi
20613
20614
20615 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20616 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20617 # Do we have a bin/java?
20618 if test ! -x "$BOOT_JDK/bin/java"; then
20619 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20620 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20621 BOOT_JDK_FOUND=no
20622 else
20623 # Do we have a bin/javac?
20624 if test ! -x "$BOOT_JDK/bin/javac"; then
20625 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20626 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20627 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20628 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20629 BOOT_JDK_FOUND=no
20630 else
20631 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20632 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20633
20634 # Extra M4 quote needed to protect [] in grep expression.
20635 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20636 if test "x$FOUND_CORRECT_VERSION" = x; then
20637 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20638 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20639 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20640 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20641 BOOT_JDK_FOUND=no
20642 else
20643 # We're done! :-)
20644 BOOT_JDK_FOUND=yes
20645
20646 # Only process if variable expands to non-empty
20647
20648 if test "x$BOOT_JDK" != x; then
20649 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20650
20651 # Input might be given as Windows format, start by converting to
20652 # unix format.
20653 path="$BOOT_JDK"
20654 new_path=`$CYGPATH -u "$path"`
20655
20656 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20657 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20658 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20659 # "foo.exe" is OK but "foo" is an error.
20660 #
20661 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20662 # It is also a way to make sure we got the proper file name for the real test later on.
20663 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20664 if test "x$test_shortpath" = x; then
20665 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20666 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20667 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20668 fi
20669
20670 # Call helper function which possibly converts this using DOS-style short mode.
20671 # If so, the updated path is stored in $new_path.
20672
20673 input_path="$new_path"
20674 # Check if we need to convert this using DOS-style short mode. If the path
20675 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20676 # take no chances and rewrite it.
20677 # Note: m4 eats our [], so we need to use [ and ] instead.
20678 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20679 if test "x$has_forbidden_chars" != x; then
20680 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20681 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20682 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20683 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20684 # Going to short mode and back again did indeed matter. Since short mode is
20685 # case insensitive, let's make it lowercase to improve readability.
20686 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20687 # Now convert it back to Unix-stile (cygpath)
20688 input_path=`$CYGPATH -u "$shortmode_path"`
20689 new_path="$input_path"
20690 fi
20691 fi
20692
20693 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20694 if test "x$test_cygdrive_prefix" = x; then
20695 # As a simple fix, exclude /usr/bin since it's not a real path.
20696 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20697 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20698 # a path prefixed by /cygdrive for fixpath to work.
20699 new_path="$CYGWIN_ROOT_PATH$input_path"
20700 fi
20701 fi
20702
20703
20704 if test "x$path" != "x$new_path"; then
20705 BOOT_JDK="$new_path"
20706 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20707 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20708 fi
20709
20710 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20711
20712 path="$BOOT_JDK"
20713 has_colon=`$ECHO $path | $GREP ^.:`
20714 new_path="$path"
20715 if test "x$has_colon" = x; then
20716 # Not in mixed or Windows style, start by that.
20717 new_path=`cmd //c echo $path`
20718 fi
20719
20720
20721 input_path="$new_path"
20722 # Check if we need to convert this using DOS-style short mode. If the path
20723 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20724 # take no chances and rewrite it.
20725 # Note: m4 eats our [], so we need to use [ and ] instead.
20726 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20727 if test "x$has_forbidden_chars" != x; then
20728 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20729 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20730 fi
20731
20732
20733 windows_path="$new_path"
20734 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20735 unix_path=`$CYGPATH -u "$windows_path"`
20736 new_path="$unix_path"
20737 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20738 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20739 new_path="$unix_path"
20740 fi
20741
20742 if test "x$path" != "x$new_path"; then
20743 BOOT_JDK="$new_path"
20744 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20745 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20746 fi
20747
20748 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20749 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20750
20751 else
20752 # We're on a unix platform. Hooray! :)
20753 path="$BOOT_JDK"
20754 has_space=`$ECHO "$path" | $GREP " "`
20755 if test "x$has_space" != x; then
20756 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20757 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20758 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20759 fi
20760
20761 # Use eval to expand a potential ~
20762 eval path="$path"
20763 if test ! -f "$path" && test ! -d "$path"; then
20764 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20765 fi
20766
20767 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20768 fi
20769 fi
20770
20771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20772 $as_echo_n "checking for Boot JDK... " >&6; }
20773 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20774 $as_echo "$BOOT_JDK" >&6; }
20775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20776 $as_echo_n "checking Boot JDK version... " >&6; }
20777 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20778 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20779 $as_echo "$BOOT_JDK_VERSION" >&6; }
20780 fi # end check jdk version
20781 fi # end check javac
20782 fi # end check java
20783 fi # end check boot jdk found
20784 fi
20785
20786 # If that did not work out (e.g. too old), try explicit versions instead
20787
20788 if test "x$BOOT_JDK_FOUND" = xno; then
20789 # Now execute the test
20790
20791 if test -x /usr/libexec/java_home; then
20792 BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20793 BOOT_JDK_FOUND=maybe
20794 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20795 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20796 fi
20797
20798
20799 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20800 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20801 # Do we have a bin/java?
20802 if test ! -x "$BOOT_JDK/bin/java"; then
20803 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20804 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20805 BOOT_JDK_FOUND=no
20806 else
20807 # Do we have a bin/javac?
20808 if test ! -x "$BOOT_JDK/bin/javac"; then
20809 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20810 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20811 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20812 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20813 BOOT_JDK_FOUND=no
20814 else
20815 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20816 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20817
20818 # Extra M4 quote needed to protect [] in grep expression.
20819 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20820 if test "x$FOUND_CORRECT_VERSION" = x; then
20821 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20822 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20823 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20824 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20825 BOOT_JDK_FOUND=no
20826 else
20827 # We're done! :-)
20828 BOOT_JDK_FOUND=yes
20829
20830 # Only process if variable expands to non-empty
20831
20832 if test "x$BOOT_JDK" != x; then
20833 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20834
20835 # Input might be given as Windows format, start by converting to
20836 # unix format.
20837 path="$BOOT_JDK"
20838 new_path=`$CYGPATH -u "$path"`
20839
20840 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20841 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20842 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20843 # "foo.exe" is OK but "foo" is an error.
20844 #
20845 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20846 # It is also a way to make sure we got the proper file name for the real test later on.
20847 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20848 if test "x$test_shortpath" = x; then
20849 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20850 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20851 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20852 fi
20853
20854 # Call helper function which possibly converts this using DOS-style short mode.
20855 # If so, the updated path is stored in $new_path.
20856
20857 input_path="$new_path"
20858 # Check if we need to convert this using DOS-style short mode. If the path
20859 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20860 # take no chances and rewrite it.
20861 # Note: m4 eats our [], so we need to use [ and ] instead.
20862 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20863 if test "x$has_forbidden_chars" != x; then
20864 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20865 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20866 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20867 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20868 # Going to short mode and back again did indeed matter. Since short mode is
20869 # case insensitive, let's make it lowercase to improve readability.
20870 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20871 # Now convert it back to Unix-stile (cygpath)
20872 input_path=`$CYGPATH -u "$shortmode_path"`
20873 new_path="$input_path"
20874 fi
20875 fi
20876
20877 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20878 if test "x$test_cygdrive_prefix" = x; then
20879 # As a simple fix, exclude /usr/bin since it's not a real path.
20880 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20881 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20882 # a path prefixed by /cygdrive for fixpath to work.
20883 new_path="$CYGWIN_ROOT_PATH$input_path"
20884 fi
20885 fi
20886
20887
20888 if test "x$path" != "x$new_path"; then
20889 BOOT_JDK="$new_path"
20890 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20891 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20892 fi
20893
20894 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20895
20896 path="$BOOT_JDK"
20897 has_colon=`$ECHO $path | $GREP ^.:`
20898 new_path="$path"
20899 if test "x$has_colon" = x; then
20900 # Not in mixed or Windows style, start by that.
20901 new_path=`cmd //c echo $path`
20902 fi
20903
20904
20905 input_path="$new_path"
20906 # Check if we need to convert this using DOS-style short mode. If the path
20907 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20908 # take no chances and rewrite it.
20909 # Note: m4 eats our [], so we need to use [ and ] instead.
20910 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20911 if test "x$has_forbidden_chars" != x; then
20912 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20913 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20914 fi
20915
20916
20917 windows_path="$new_path"
20918 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20919 unix_path=`$CYGPATH -u "$windows_path"`
20920 new_path="$unix_path"
20921 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20922 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20923 new_path="$unix_path"
20924 fi
20925
20926 if test "x$path" != "x$new_path"; then
20927 BOOT_JDK="$new_path"
20928 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20929 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20930 fi
20931
20932 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20933 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20934
20935 else
20936 # We're on a unix platform. Hooray! :)
20937 path="$BOOT_JDK"
20938 has_space=`$ECHO "$path" | $GREP " "`
20939 if test "x$has_space" != x; then
20940 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20941 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20942 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20943 fi
20944
20945 # Use eval to expand a potential ~
20946 eval path="$path"
20947 if test ! -f "$path" && test ! -d "$path"; then
20948 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20949 fi
20950
20951 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20952 fi
20953 fi
20954
20955 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20956 $as_echo_n "checking for Boot JDK... " >&6; }
20957 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20958 $as_echo "$BOOT_JDK" >&6; }
20959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20960 $as_echo_n "checking Boot JDK version... " >&6; }
20961 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20962 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20963 $as_echo "$BOOT_JDK_VERSION" >&6; }
20964 fi # end check jdk version
20965 fi # end check javac
20966 fi # end check java
20967 fi # end check boot jdk found
20968 fi
20969
20970
20971 if test "x$BOOT_JDK_FOUND" = xno; then
20972 # Now execute the test
20973
20974 if test -x /usr/libexec/java_home; then
20975 BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20976 BOOT_JDK_FOUND=maybe
20977 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20978 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20979 fi
20980
20981
20982 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20983 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20984 # Do we have a bin/java?
20985 if test ! -x "$BOOT_JDK/bin/java"; then
20986 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20987 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20988 BOOT_JDK_FOUND=no
20989 else
20990 # Do we have a bin/javac?
20991 if test ! -x "$BOOT_JDK/bin/javac"; then
20992 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20993 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20994 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20995 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20996 BOOT_JDK_FOUND=no
20997 else
20998 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20999 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21000
21001 # Extra M4 quote needed to protect [] in grep expression.
21002 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21003 if test "x$FOUND_CORRECT_VERSION" = x; then
21004 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21005 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21006 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21007 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21008 BOOT_JDK_FOUND=no
21009 else
21010 # We're done! :-)
21011 BOOT_JDK_FOUND=yes
21012
21013 # Only process if variable expands to non-empty
21014
21015 if test "x$BOOT_JDK" != x; then
21016 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21017
21018 # Input might be given as Windows format, start by converting to
21019 # unix format.
21020 path="$BOOT_JDK"
21021 new_path=`$CYGPATH -u "$path"`
21022
21023 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21024 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21025 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21026 # "foo.exe" is OK but "foo" is an error.
21027 #
21028 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21029 # It is also a way to make sure we got the proper file name for the real test later on.
21030 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21031 if test "x$test_shortpath" = x; then
21032 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21033 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21034 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21035 fi
21036
21037 # Call helper function which possibly converts this using DOS-style short mode.
21038 # If so, the updated path is stored in $new_path.
21039
21040 input_path="$new_path"
21041 # Check if we need to convert this using DOS-style short mode. If the path
21042 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21043 # take no chances and rewrite it.
21044 # Note: m4 eats our [], so we need to use [ and ] instead.
21045 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21046 if test "x$has_forbidden_chars" != x; then
21047 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21048 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21049 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21050 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21051 # Going to short mode and back again did indeed matter. Since short mode is
21052 # case insensitive, let's make it lowercase to improve readability.
21053 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21054 # Now convert it back to Unix-stile (cygpath)
21055 input_path=`$CYGPATH -u "$shortmode_path"`
21056 new_path="$input_path"
21057 fi
21058 fi
21059
21060 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21061 if test "x$test_cygdrive_prefix" = x; then
21062 # As a simple fix, exclude /usr/bin since it's not a real path.
21063 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21064 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21065 # a path prefixed by /cygdrive for fixpath to work.
21066 new_path="$CYGWIN_ROOT_PATH$input_path"
21067 fi
21068 fi
21069
21070
21071 if test "x$path" != "x$new_path"; then
21072 BOOT_JDK="$new_path"
21073 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21074 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21075 fi
21076
21077 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21078
21079 path="$BOOT_JDK"
21080 has_colon=`$ECHO $path | $GREP ^.:`
21081 new_path="$path"
21082 if test "x$has_colon" = x; then
21083 # Not in mixed or Windows style, start by that.
21084 new_path=`cmd //c echo $path`
21085 fi
21086
21087
21088 input_path="$new_path"
21089 # Check if we need to convert this using DOS-style short mode. If the path
21090 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21091 # take no chances and rewrite it.
21092 # Note: m4 eats our [], so we need to use [ and ] instead.
21093 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21094 if test "x$has_forbidden_chars" != x; then
21095 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21096 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21097 fi
21098
21099
21100 windows_path="$new_path"
21101 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21102 unix_path=`$CYGPATH -u "$windows_path"`
21103 new_path="$unix_path"
21104 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21105 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21106 new_path="$unix_path"
21107 fi
21108
21109 if test "x$path" != "x$new_path"; then
21110 BOOT_JDK="$new_path"
21111 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21112 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21113 fi
21114
21115 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21116 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21117
21118 else
21119 # We're on a unix platform. Hooray! :)
21120 path="$BOOT_JDK"
21121 has_space=`$ECHO "$path" | $GREP " "`
21122 if test "x$has_space" != x; then
21123 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21124 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21125 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21126 fi
21127
21128 # Use eval to expand a potential ~
21129 eval path="$path"
21130 if test ! -f "$path" && test ! -d "$path"; then
21131 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21132 fi
21133
21134 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21135 fi
21136 fi
21137
21138 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21139 $as_echo_n "checking for Boot JDK... " >&6; }
21140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21141 $as_echo "$BOOT_JDK" >&6; }
21142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21143 $as_echo_n "checking Boot JDK version... " >&6; }
21144 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21145 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21146 $as_echo "$BOOT_JDK_VERSION" >&6; }
21147 fi # end check jdk version
21148 fi # end check javac
21149 fi # end check java
21150 fi # end check boot jdk found
21151 fi
21152
21153
21154 if test "x$BOOT_JDK_FOUND" = xno; then
21155 # Now execute the test
21156
21157 if test -x /usr/libexec/java_home; then
21158 BOOT_JDK=`/usr/libexec/java_home -v 1.7`
21159 BOOT_JDK_FOUND=maybe
21160 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
21161 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
21162 fi
21163
21164
21165 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21166 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21167 # Do we have a bin/java?
21168 if test ! -x "$BOOT_JDK/bin/java"; then
21169 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21170 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21171 BOOT_JDK_FOUND=no
21172 else
21173 # Do we have a bin/javac?
21174 if test ! -x "$BOOT_JDK/bin/javac"; then
21175 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21176 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21177 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21178 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21179 BOOT_JDK_FOUND=no
21180 else
21181 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21182 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21183
21184 # Extra M4 quote needed to protect [] in grep expression.
21185 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21186 if test "x$FOUND_CORRECT_VERSION" = x; then
21187 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21188 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21189 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21190 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21191 BOOT_JDK_FOUND=no
21192 else
21193 # We're done! :-)
21194 BOOT_JDK_FOUND=yes
21195
21196 # Only process if variable expands to non-empty
21197
21198 if test "x$BOOT_JDK" != x; then
21199 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21200
21201 # Input might be given as Windows format, start by converting to
21202 # unix format.
21203 path="$BOOT_JDK"
21204 new_path=`$CYGPATH -u "$path"`
21205
21206 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21207 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21208 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21209 # "foo.exe" is OK but "foo" is an error.
21210 #
21211 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21212 # It is also a way to make sure we got the proper file name for the real test later on.
21213 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21214 if test "x$test_shortpath" = x; then
21215 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21216 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21217 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21218 fi
21219
21220 # Call helper function which possibly converts this using DOS-style short mode.
21221 # If so, the updated path is stored in $new_path.
21222
21223 input_path="$new_path"
21224 # Check if we need to convert this using DOS-style short mode. If the path
21225 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21226 # take no chances and rewrite it.
21227 # Note: m4 eats our [], so we need to use [ and ] instead.
21228 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21229 if test "x$has_forbidden_chars" != x; then
21230 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21231 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21232 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21233 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21234 # Going to short mode and back again did indeed matter. Since short mode is
21235 # case insensitive, let's make it lowercase to improve readability.
21236 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21237 # Now convert it back to Unix-stile (cygpath)
21238 input_path=`$CYGPATH -u "$shortmode_path"`
21239 new_path="$input_path"
21240 fi
21241 fi
21242
21243 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21244 if test "x$test_cygdrive_prefix" = x; then
21245 # As a simple fix, exclude /usr/bin since it's not a real path.
21246 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21247 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21248 # a path prefixed by /cygdrive for fixpath to work.
21249 new_path="$CYGWIN_ROOT_PATH$input_path"
21250 fi
21251 fi
21252
21253
21254 if test "x$path" != "x$new_path"; then
21255 BOOT_JDK="$new_path"
21256 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21257 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21258 fi
21259
21260 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21261
21262 path="$BOOT_JDK"
21263 has_colon=`$ECHO $path | $GREP ^.:`
21264 new_path="$path"
21265 if test "x$has_colon" = x; then
21266 # Not in mixed or Windows style, start by that.
21267 new_path=`cmd //c echo $path`
21268 fi
21269
21270
21271 input_path="$new_path"
21272 # Check if we need to convert this using DOS-style short mode. If the path
21273 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21274 # take no chances and rewrite it.
21275 # Note: m4 eats our [], so we need to use [ and ] instead.
21276 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21277 if test "x$has_forbidden_chars" != x; then
21278 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21279 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21280 fi
21281
21282
21283 windows_path="$new_path"
21284 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21285 unix_path=`$CYGPATH -u "$windows_path"`
21286 new_path="$unix_path"
21287 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21288 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21289 new_path="$unix_path"
21290 fi
21291
21292 if test "x$path" != "x$new_path"; then
21293 BOOT_JDK="$new_path"
21294 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21295 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21296 fi
21297
21298 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21299 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21300
21301 else
21302 # We're on a unix platform. Hooray! :)
21303 path="$BOOT_JDK"
21304 has_space=`$ECHO "$path" | $GREP " "`
21305 if test "x$has_space" != x; then
21306 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21307 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21308 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21309 fi
21310
21311 # Use eval to expand a potential ~
21312 eval path="$path"
21313 if test ! -f "$path" && test ! -d "$path"; then
21314 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21315 fi
21316
21317 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21318 fi
21319 fi
21320
21321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21322 $as_echo_n "checking for Boot JDK... " >&6; }
21323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21324 $as_echo "$BOOT_JDK" >&6; }
21325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21326 $as_echo_n "checking Boot JDK version... " >&6; }
21327 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21328 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21329 $as_echo "$BOOT_JDK_VERSION" >&6; }
21330 fi # end check jdk version
21331 fi # end check javac
21332 fi # end check java
21333 fi # end check boot jdk found
21334 fi
21335
21336 fi
21337
21338
21339 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21340 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21341 # Do we have a bin/java?
21342 if test ! -x "$BOOT_JDK/bin/java"; then
21343 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21344 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21345 BOOT_JDK_FOUND=no
21346 else
21347 # Do we have a bin/javac?
21348 if test ! -x "$BOOT_JDK/bin/javac"; then
21349 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21350 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21351 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21352 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21353 BOOT_JDK_FOUND=no
21354 else
21355 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21356 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21357
21358 # Extra M4 quote needed to protect [] in grep expression.
21359 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21360 if test "x$FOUND_CORRECT_VERSION" = x; then
21361 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21362 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21363 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21364 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21365 BOOT_JDK_FOUND=no
21366 else
21367 # We're done! :-)
21368 BOOT_JDK_FOUND=yes
21369
21370 # Only process if variable expands to non-empty
21371
21372 if test "x$BOOT_JDK" != x; then
21373 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21374
21375 # Input might be given as Windows format, start by converting to
21376 # unix format.
21377 path="$BOOT_JDK"
21378 new_path=`$CYGPATH -u "$path"`
21379
21380 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21381 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21382 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21383 # "foo.exe" is OK but "foo" is an error.
21384 #
21385 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21386 # It is also a way to make sure we got the proper file name for the real test later on.
21387 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21388 if test "x$test_shortpath" = x; then
21389 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21390 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21391 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21392 fi
21393
21394 # Call helper function which possibly converts this using DOS-style short mode.
21395 # If so, the updated path is stored in $new_path.
21396
21397 input_path="$new_path"
21398 # Check if we need to convert this using DOS-style short mode. If the path
21399 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21400 # take no chances and rewrite it.
21401 # Note: m4 eats our [], so we need to use [ and ] instead.
21402 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21403 if test "x$has_forbidden_chars" != x; then
21404 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21405 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21406 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21407 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21408 # Going to short mode and back again did indeed matter. Since short mode is
21409 # case insensitive, let's make it lowercase to improve readability.
21410 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21411 # Now convert it back to Unix-stile (cygpath)
21412 input_path=`$CYGPATH -u "$shortmode_path"`
21413 new_path="$input_path"
21414 fi
21415 fi
21416
21417 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21418 if test "x$test_cygdrive_prefix" = x; then
21419 # As a simple fix, exclude /usr/bin since it's not a real path.
21420 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21421 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21422 # a path prefixed by /cygdrive for fixpath to work.
21423 new_path="$CYGWIN_ROOT_PATH$input_path"
21424 fi
21425 fi
21426
21427
21428 if test "x$path" != "x$new_path"; then
21429 BOOT_JDK="$new_path"
21430 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21431 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21432 fi
21433
21434 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21435
21436 path="$BOOT_JDK"
21437 has_colon=`$ECHO $path | $GREP ^.:`
21438 new_path="$path"
21439 if test "x$has_colon" = x; then
21440 # Not in mixed or Windows style, start by that.
21441 new_path=`cmd //c echo $path`
21442 fi
21443
21444
21445 input_path="$new_path"
21446 # Check if we need to convert this using DOS-style short mode. If the path
21447 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21448 # take no chances and rewrite it.
21449 # Note: m4 eats our [], so we need to use [ and ] instead.
21450 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21451 if test "x$has_forbidden_chars" != x; then
21452 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21453 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21454 fi
21455
21456
21457 windows_path="$new_path"
21458 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21459 unix_path=`$CYGPATH -u "$windows_path"`
21460 new_path="$unix_path"
21461 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21462 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21463 new_path="$unix_path"
21464 fi
21465
21466 if test "x$path" != "x$new_path"; then
21467 BOOT_JDK="$new_path"
21468 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21469 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21470 fi
21471
21472 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21473 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21474
21475 else
21476 # We're on a unix platform. Hooray! :)
21477 path="$BOOT_JDK"
21478 has_space=`$ECHO "$path" | $GREP " "`
21479 if test "x$has_space" != x; then
21480 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21481 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21482 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21483 fi
21484
21485 # Use eval to expand a potential ~
21486 eval path="$path"
21487 if test ! -f "$path" && test ! -d "$path"; then
21488 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21489 fi
21490
21491 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21492 fi
21493 fi
21494
21495 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21496 $as_echo_n "checking for Boot JDK... " >&6; }
21497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21498 $as_echo "$BOOT_JDK" >&6; }
21499 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21500 $as_echo_n "checking Boot JDK version... " >&6; }
21501 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21503 $as_echo "$BOOT_JDK_VERSION" >&6; }
21504 fi # end check jdk version
21505 fi # end check javac
21506 fi # end check java
21507 fi # end check boot jdk found
21508 fi
21509
21510
21511 # Test: Is $JAVA_HOME set?
21512
21513 if test "x$BOOT_JDK_FOUND" = xno; then
21514 # Now execute the test
21515
21516 if test "x$JAVA_HOME" != x; then
21517 JAVA_HOME_PROCESSED="$JAVA_HOME"
21518
21519 # Only process if variable expands to non-empty
21520
21521 if test "x$JAVA_HOME_PROCESSED" != x; then
21522 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21523
21524 # Input might be given as Windows format, start by converting to
21525 # unix format.
21526 path="$JAVA_HOME_PROCESSED"
21527 new_path=`$CYGPATH -u "$path"`
21528
21529 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21530 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21531 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21532 # "foo.exe" is OK but "foo" is an error.
21533 #
21534 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21535 # It is also a way to make sure we got the proper file name for the real test later on.
21536 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21537 if test "x$test_shortpath" = x; then
21538 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21539 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21540 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
21541 fi
21542
21543 # Call helper function which possibly converts this using DOS-style short mode.
21544 # If so, the updated path is stored in $new_path.
21545
21546 input_path="$new_path"
21547 # Check if we need to convert this using DOS-style short mode. If the path
21548 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21549 # take no chances and rewrite it.
21550 # Note: m4 eats our [], so we need to use [ and ] instead.
21551 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21552 if test "x$has_forbidden_chars" != x; then
21553 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21554 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21555 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21556 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21557 # Going to short mode and back again did indeed matter. Since short mode is
21558 # case insensitive, let's make it lowercase to improve readability.
21559 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21560 # Now convert it back to Unix-stile (cygpath)
21561 input_path=`$CYGPATH -u "$shortmode_path"`
21562 new_path="$input_path"
21563 fi
21564 fi
21565
21566 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21567 if test "x$test_cygdrive_prefix" = x; then
21568 # As a simple fix, exclude /usr/bin since it's not a real path.
21569 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21570 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21571 # a path prefixed by /cygdrive for fixpath to work.
21572 new_path="$CYGWIN_ROOT_PATH$input_path"
21573 fi
21574 fi
21575
21576
21577 if test "x$path" != "x$new_path"; then
21578 JAVA_HOME_PROCESSED="$new_path"
21579 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21580 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21581 fi
21582
21583 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21584
21585 path="$JAVA_HOME_PROCESSED"
21586 has_colon=`$ECHO $path | $GREP ^.:`
21587 new_path="$path"
21588 if test "x$has_colon" = x; then
21589 # Not in mixed or Windows style, start by that.
21590 new_path=`cmd //c echo $path`
21591 fi
21592
21593
21594 input_path="$new_path"
21595 # Check if we need to convert this using DOS-style short mode. If the path
21596 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21597 # take no chances and rewrite it.
21598 # Note: m4 eats our [], so we need to use [ and ] instead.
21599 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21600 if test "x$has_forbidden_chars" != x; then
21601 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21602 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21603 fi
21604
21605
21606 windows_path="$new_path"
21607 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21608 unix_path=`$CYGPATH -u "$windows_path"`
21609 new_path="$unix_path"
21610 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21611 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21612 new_path="$unix_path"
21613 fi
21614
21615 if test "x$path" != "x$new_path"; then
21616 JAVA_HOME_PROCESSED="$new_path"
21617 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21618 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21619 fi
21620
21621 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21622 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21623
21624 else
21625 # We're on a unix platform. Hooray! :)
21626 path="$JAVA_HOME_PROCESSED"
21627 has_space=`$ECHO "$path" | $GREP " "`
21628 if test "x$has_space" != x; then
21629 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21630 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21631 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21632 fi
21633
21634 # Use eval to expand a potential ~
21635 eval path="$path"
21636 if test ! -f "$path" && test ! -d "$path"; then
21637 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21638 fi
21639
21640 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21641 fi
21642 fi
21643
21644 if test ! -d "$JAVA_HOME_PROCESSED"; then
21645 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21646 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21647 else
21648 # Aha, the user has set a JAVA_HOME
21649 # let us use that as the Boot JDK.
21650 BOOT_JDK="$JAVA_HOME_PROCESSED"
21651 BOOT_JDK_FOUND=maybe
21652 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21653 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21654 fi
21655 fi
21656
21657
21658 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21659 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21660 # Do we have a bin/java?
21661 if test ! -x "$BOOT_JDK/bin/java"; then
21662 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21663 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21664 BOOT_JDK_FOUND=no
21665 else
21666 # Do we have a bin/javac?
21667 if test ! -x "$BOOT_JDK/bin/javac"; then
21668 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21669 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21670 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21671 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21672 BOOT_JDK_FOUND=no
21673 else
21674 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21675 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21676
21677 # Extra M4 quote needed to protect [] in grep expression.
21678 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21679 if test "x$FOUND_CORRECT_VERSION" = x; then
21680 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21681 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21682 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21683 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21684 BOOT_JDK_FOUND=no
21685 else
21686 # We're done! :-)
21687 BOOT_JDK_FOUND=yes
21688
21689 # Only process if variable expands to non-empty
21690
21691 if test "x$BOOT_JDK" != x; then
21692 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21693
21694 # Input might be given as Windows format, start by converting to
21695 # unix format.
21696 path="$BOOT_JDK"
21697 new_path=`$CYGPATH -u "$path"`
21698
21699 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21700 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21701 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21702 # "foo.exe" is OK but "foo" is an error.
21703 #
21704 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21705 # It is also a way to make sure we got the proper file name for the real test later on.
21706 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21707 if test "x$test_shortpath" = x; then
21708 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21709 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21710 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21711 fi
21712
21713 # Call helper function which possibly converts this using DOS-style short mode.
21714 # If so, the updated path is stored in $new_path.
21715
21716 input_path="$new_path"
21717 # Check if we need to convert this using DOS-style short mode. If the path
21718 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21719 # take no chances and rewrite it.
21720 # Note: m4 eats our [], so we need to use [ and ] instead.
21721 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21722 if test "x$has_forbidden_chars" != x; then
21723 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21724 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21725 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21726 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21727 # Going to short mode and back again did indeed matter. Since short mode is
21728 # case insensitive, let's make it lowercase to improve readability.
21729 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21730 # Now convert it back to Unix-stile (cygpath)
21731 input_path=`$CYGPATH -u "$shortmode_path"`
21732 new_path="$input_path"
21733 fi
21734 fi
21735
21736 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21737 if test "x$test_cygdrive_prefix" = x; then
21738 # As a simple fix, exclude /usr/bin since it's not a real path.
21739 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21740 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21741 # a path prefixed by /cygdrive for fixpath to work.
21742 new_path="$CYGWIN_ROOT_PATH$input_path"
21743 fi
21744 fi
21745
21746
21747 if test "x$path" != "x$new_path"; then
21748 BOOT_JDK="$new_path"
21749 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21750 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21751 fi
21752
21753 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21754
21755 path="$BOOT_JDK"
21756 has_colon=`$ECHO $path | $GREP ^.:`
21757 new_path="$path"
21758 if test "x$has_colon" = x; then
21759 # Not in mixed or Windows style, start by that.
21760 new_path=`cmd //c echo $path`
21761 fi
21762
21763
21764 input_path="$new_path"
21765 # Check if we need to convert this using DOS-style short mode. If the path
21766 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21767 # take no chances and rewrite it.
21768 # Note: m4 eats our [], so we need to use [ and ] instead.
21769 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21770 if test "x$has_forbidden_chars" != x; then
21771 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21772 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21773 fi
21774
21775
21776 windows_path="$new_path"
21777 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21778 unix_path=`$CYGPATH -u "$windows_path"`
21779 new_path="$unix_path"
21780 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21781 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21782 new_path="$unix_path"
21783 fi
21784
21785 if test "x$path" != "x$new_path"; then
21786 BOOT_JDK="$new_path"
21787 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21788 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21789 fi
21790
21791 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21792 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21793
21794 else
21795 # We're on a unix platform. Hooray! :)
21796 path="$BOOT_JDK"
21797 has_space=`$ECHO "$path" | $GREP " "`
21798 if test "x$has_space" != x; then
21799 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21800 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21801 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21802 fi
21803
21804 # Use eval to expand a potential ~
21805 eval path="$path"
21806 if test ! -f "$path" && test ! -d "$path"; then
21807 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21808 fi
21809
21810 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21811 fi
21812 fi
21813
21814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21815 $as_echo_n "checking for Boot JDK... " >&6; }
21816 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21817 $as_echo "$BOOT_JDK" >&6; }
21818 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21819 $as_echo_n "checking Boot JDK version... " >&6; }
21820 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21821 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21822 $as_echo "$BOOT_JDK_VERSION" >&6; }
21823 fi # end check jdk version
21824 fi # end check javac
21825 fi # end check java
21826 fi # end check boot jdk found
21827 fi
21828
21829
21830 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21831
21832 if test "x$BOOT_JDK_FOUND" = xno; then
21833 # Now execute the test
21834
21835 # Extract the first word of "javac", so it can be a program name with args.
21836 set dummy javac; ac_word=$2
21837 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21838 $as_echo_n "checking for $ac_word... " >&6; }
21839 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21840 $as_echo_n "(cached) " >&6
21841 else
21842 case $JAVAC_CHECK in
21843 [\\/]* | ?:[\\/]*)
21844 ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21845 ;;
21846 *)
21847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21848 for as_dir in $PATH
21849 do
21850 IFS=$as_save_IFS
21851 test -z "$as_dir" && as_dir=.
21852 for ac_exec_ext in '' $ac_executable_extensions; do
21853 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21854 ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21855 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21856 break 2
21857 fi
21858 done
21859 done
21860 IFS=$as_save_IFS
21861
21862 ;;
21863 esac
21864 fi
21865 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21866 if test -n "$JAVAC_CHECK"; then
21867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21868 $as_echo "$JAVAC_CHECK" >&6; }
21869 else
21870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21871 $as_echo "no" >&6; }
21872 fi
21873
21874
21875 # Extract the first word of "java", so it can be a program name with args.
21876 set dummy java; ac_word=$2
21877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21878 $as_echo_n "checking for $ac_word... " >&6; }
21879 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21880 $as_echo_n "(cached) " >&6
21881 else
21882 case $JAVA_CHECK in
21883 [\\/]* | ?:[\\/]*)
21884 ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21885 ;;
21886 *)
21887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21888 for as_dir in $PATH
21889 do
21890 IFS=$as_save_IFS
21891 test -z "$as_dir" && as_dir=.
21892 for ac_exec_ext in '' $ac_executable_extensions; do
21893 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21894 ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21895 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21896 break 2
21897 fi
21898 done
21899 done
21900 IFS=$as_save_IFS
21901
21902 ;;
21903 esac
21904 fi
21905 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21906 if test -n "$JAVA_CHECK"; then
21907 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21908 $as_echo "$JAVA_CHECK" >&6; }
21909 else
21910 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21911 $as_echo "no" >&6; }
21912 fi
21913
21914
21915 BINARY="$JAVAC_CHECK"
21916 if test "x$JAVAC_CHECK" = x; then
21917 BINARY="$JAVA_CHECK"
21918 fi
21919 if test "x$BINARY" != x; then
21920 # So there is a java(c) binary, it might be part of a JDK.
21921 # Lets find the JDK/JRE directory by following symbolic links.
21922 # Linux/GNU systems often have links from /usr/bin/java to
21923 # /etc/alternatives/java to the real JDK binary.
21924
21925 if test "x$OPENJDK_BUILD_OS" != xwindows; then
21926 # Follow a chain of symbolic links. Use readlink
21927 # where it exists, else fall back to horribly
21928 # complicated shell code.
21929 if test "x$READLINK_TESTED" != yes; then
21930 # On MacOSX there is a readlink tool with a different
21931 # purpose than the GNU readlink tool. Check the found readlink.
21932 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21933 if test "x$ISGNU" = x; then
21934 # A readlink that we do not know how to use.
21935 # Are there other non-GNU readlinks out there?
21936 READLINK_TESTED=yes
21937 READLINK=
21938 fi
21939 fi
21940
21941 if test "x$READLINK" != x; then
21942 BINARY=`$READLINK -f $BINARY`
21943 else
21944 # Save the current directory for restoring afterwards
21945 STARTDIR=$PWD
21946 COUNTER=0
21947 sym_link_dir=`$DIRNAME $BINARY`
21948 sym_link_file=`$BASENAME $BINARY`
21949 cd $sym_link_dir
21950 # Use -P flag to resolve symlinks in directories.
21951 cd `$THEPWDCMD -P`
21952 sym_link_dir=`$THEPWDCMD -P`
21953 # Resolve file symlinks
21954 while test $COUNTER -lt 20; do
21955 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21956 if test "x$ISLINK" == x; then
21957 # This is not a symbolic link! We are done!
21958 break
21959 fi
21960 # Again resolve directory symlinks since the target of the just found
21961 # link could be in a different directory
21962 cd `$DIRNAME $ISLINK`
21963 sym_link_dir=`$THEPWDCMD -P`
21964 sym_link_file=`$BASENAME $ISLINK`
21965 let COUNTER=COUNTER+1
21966 done
21967 cd $STARTDIR
21968 BINARY=$sym_link_dir/$sym_link_file
21969 fi
21970 fi
21971
21972 BOOT_JDK=`dirname "$BINARY"`
21973 BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21974 if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21975 # Looks like we found ourselves an JDK
21976 BOOT_JDK_FOUND=maybe
21977 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21978 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21979 fi
21980 fi
21981
21982
21983 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21984 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21985 # Do we have a bin/java?
21986 if test ! -x "$BOOT_JDK/bin/java"; then
21987 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21988 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21989 BOOT_JDK_FOUND=no
21990 else
21991 # Do we have a bin/javac?
21992 if test ! -x "$BOOT_JDK/bin/javac"; then
21993 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21995 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21997 BOOT_JDK_FOUND=no
21998 else
21999 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22000 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22001
22002 # Extra M4 quote needed to protect [] in grep expression.
22003 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22004 if test "x$FOUND_CORRECT_VERSION" = x; then
22005 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22006 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22007 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22008 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22009 BOOT_JDK_FOUND=no
22010 else
22011 # We're done! :-)
22012 BOOT_JDK_FOUND=yes
22013
22014 # Only process if variable expands to non-empty
22015
22016 if test "x$BOOT_JDK" != x; then
22017 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22018
22019 # Input might be given as Windows format, start by converting to
22020 # unix format.
22021 path="$BOOT_JDK"
22022 new_path=`$CYGPATH -u "$path"`
22023
22024 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22025 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22026 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22027 # "foo.exe" is OK but "foo" is an error.
22028 #
22029 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22030 # It is also a way to make sure we got the proper file name for the real test later on.
22031 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22032 if test "x$test_shortpath" = x; then
22033 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22034 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22035 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22036 fi
22037
22038 # Call helper function which possibly converts this using DOS-style short mode.
22039 # If so, the updated path is stored in $new_path.
22040
22041 input_path="$new_path"
22042 # Check if we need to convert this using DOS-style short mode. If the path
22043 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22044 # take no chances and rewrite it.
22045 # Note: m4 eats our [], so we need to use [ and ] instead.
22046 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22047 if test "x$has_forbidden_chars" != x; then
22048 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22049 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22050 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22051 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22052 # Going to short mode and back again did indeed matter. Since short mode is
22053 # case insensitive, let's make it lowercase to improve readability.
22054 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22055 # Now convert it back to Unix-stile (cygpath)
22056 input_path=`$CYGPATH -u "$shortmode_path"`
22057 new_path="$input_path"
22058 fi
22059 fi
22060
22061 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22062 if test "x$test_cygdrive_prefix" = x; then
22063 # As a simple fix, exclude /usr/bin since it's not a real path.
22064 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22065 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22066 # a path prefixed by /cygdrive for fixpath to work.
22067 new_path="$CYGWIN_ROOT_PATH$input_path"
22068 fi
22069 fi
22070
22071
22072 if test "x$path" != "x$new_path"; then
22073 BOOT_JDK="$new_path"
22074 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22075 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22076 fi
22077
22078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22079
22080 path="$BOOT_JDK"
22081 has_colon=`$ECHO $path | $GREP ^.:`
22082 new_path="$path"
22083 if test "x$has_colon" = x; then
22084 # Not in mixed or Windows style, start by that.
22085 new_path=`cmd //c echo $path`
22086 fi
22087
22088
22089 input_path="$new_path"
22090 # Check if we need to convert this using DOS-style short mode. If the path
22091 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22092 # take no chances and rewrite it.
22093 # Note: m4 eats our [], so we need to use [ and ] instead.
22094 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22095 if test "x$has_forbidden_chars" != x; then
22096 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22097 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22098 fi
22099
22100
22101 windows_path="$new_path"
22102 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22103 unix_path=`$CYGPATH -u "$windows_path"`
22104 new_path="$unix_path"
22105 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22106 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22107 new_path="$unix_path"
22108 fi
22109
22110 if test "x$path" != "x$new_path"; then
22111 BOOT_JDK="$new_path"
22112 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22113 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22114 fi
22115
22116 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22117 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22118
22119 else
22120 # We're on a unix platform. Hooray! :)
22121 path="$BOOT_JDK"
22122 has_space=`$ECHO "$path" | $GREP " "`
22123 if test "x$has_space" != x; then
22124 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22125 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22126 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22127 fi
22128
22129 # Use eval to expand a potential ~
22130 eval path="$path"
22131 if test ! -f "$path" && test ! -d "$path"; then
22132 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22133 fi
22134
22135 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22136 fi
22137 fi
22138
22139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22140 $as_echo_n "checking for Boot JDK... " >&6; }
22141 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22142 $as_echo "$BOOT_JDK" >&6; }
22143 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22144 $as_echo_n "checking Boot JDK version... " >&6; }
22145 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22146 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22147 $as_echo "$BOOT_JDK_VERSION" >&6; }
22148 fi # end check jdk version
22149 fi # end check javac
22150 fi # end check java
22151 fi # end check boot jdk found
22152 fi
22153
22154
22155 # Test: Is there a JDK installed in default, well-known locations?
22156
22157 if test "x$BOOT_JDK_FOUND" = xno; then
22158 # Now execute the test
22159
22160 if test "x$OPENJDK_TARGET_OS" = xwindows; then
22161
22162 if test "x$BOOT_JDK_FOUND" = xno; then
22163 # Now execute the test
22164
22165 if test "x$ProgramW6432" != x; then
22166 VIRTUAL_DIR="$ProgramW6432/Java"
22167
22168 windows_path="$VIRTUAL_DIR"
22169 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22170 unix_path=`$CYGPATH -u "$windows_path"`
22171 VIRTUAL_DIR="$unix_path"
22172 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22173 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22174 VIRTUAL_DIR="$unix_path"
22175 fi
22176
22177
22178 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22179 BOOT_JDK_SUFFIX=""
22180 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22181 if test "x$ALL_JDKS_FOUND" != x; then
22182 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22183
22184 if test "x$BOOT_JDK_FOUND" = xno; then
22185 # Now execute the test
22186
22187 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22188 if test -d "$BOOT_JDK"; then
22189 BOOT_JDK_FOUND=maybe
22190 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22191 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22192 fi
22193
22194
22195 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22196 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22197 # Do we have a bin/java?
22198 if test ! -x "$BOOT_JDK/bin/java"; then
22199 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22200 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22201 BOOT_JDK_FOUND=no
22202 else
22203 # Do we have a bin/javac?
22204 if test ! -x "$BOOT_JDK/bin/javac"; then
22205 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22206 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22207 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22208 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22209 BOOT_JDK_FOUND=no
22210 else
22211 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22212 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22213
22214 # Extra M4 quote needed to protect [] in grep expression.
22215 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22216 if test "x$FOUND_CORRECT_VERSION" = x; then
22217 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22219 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22220 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22221 BOOT_JDK_FOUND=no
22222 else
22223 # We're done! :-)
22224 BOOT_JDK_FOUND=yes
22225
22226 # Only process if variable expands to non-empty
22227
22228 if test "x$BOOT_JDK" != x; then
22229 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22230
22231 # Input might be given as Windows format, start by converting to
22232 # unix format.
22233 path="$BOOT_JDK"
22234 new_path=`$CYGPATH -u "$path"`
22235
22236 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22237 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22238 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22239 # "foo.exe" is OK but "foo" is an error.
22240 #
22241 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22242 # It is also a way to make sure we got the proper file name for the real test later on.
22243 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22244 if test "x$test_shortpath" = x; then
22245 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22246 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22247 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22248 fi
22249
22250 # Call helper function which possibly converts this using DOS-style short mode.
22251 # If so, the updated path is stored in $new_path.
22252
22253 input_path="$new_path"
22254 # Check if we need to convert this using DOS-style short mode. If the path
22255 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22256 # take no chances and rewrite it.
22257 # Note: m4 eats our [], so we need to use [ and ] instead.
22258 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22259 if test "x$has_forbidden_chars" != x; then
22260 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22261 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22262 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22263 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22264 # Going to short mode and back again did indeed matter. Since short mode is
22265 # case insensitive, let's make it lowercase to improve readability.
22266 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22267 # Now convert it back to Unix-stile (cygpath)
22268 input_path=`$CYGPATH -u "$shortmode_path"`
22269 new_path="$input_path"
22270 fi
22271 fi
22272
22273 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22274 if test "x$test_cygdrive_prefix" = x; then
22275 # As a simple fix, exclude /usr/bin since it's not a real path.
22276 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22277 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22278 # a path prefixed by /cygdrive for fixpath to work.
22279 new_path="$CYGWIN_ROOT_PATH$input_path"
22280 fi
22281 fi
22282
22283
22284 if test "x$path" != "x$new_path"; then
22285 BOOT_JDK="$new_path"
22286 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22287 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22288 fi
22289
22290 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22291
22292 path="$BOOT_JDK"
22293 has_colon=`$ECHO $path | $GREP ^.:`
22294 new_path="$path"
22295 if test "x$has_colon" = x; then
22296 # Not in mixed or Windows style, start by that.
22297 new_path=`cmd //c echo $path`
22298 fi
22299
22300
22301 input_path="$new_path"
22302 # Check if we need to convert this using DOS-style short mode. If the path
22303 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22304 # take no chances and rewrite it.
22305 # Note: m4 eats our [], so we need to use [ and ] instead.
22306 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22307 if test "x$has_forbidden_chars" != x; then
22308 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22309 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22310 fi
22311
22312
22313 windows_path="$new_path"
22314 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22315 unix_path=`$CYGPATH -u "$windows_path"`
22316 new_path="$unix_path"
22317 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22318 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22319 new_path="$unix_path"
22320 fi
22321
22322 if test "x$path" != "x$new_path"; then
22323 BOOT_JDK="$new_path"
22324 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22325 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22326 fi
22327
22328 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22329 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22330
22331 else
22332 # We're on a unix platform. Hooray! :)
22333 path="$BOOT_JDK"
22334 has_space=`$ECHO "$path" | $GREP " "`
22335 if test "x$has_space" != x; then
22336 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22337 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22338 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22339 fi
22340
22341 # Use eval to expand a potential ~
22342 eval path="$path"
22343 if test ! -f "$path" && test ! -d "$path"; then
22344 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22345 fi
22346
22347 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22348 fi
22349 fi
22350
22351 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22352 $as_echo_n "checking for Boot JDK... " >&6; }
22353 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22354 $as_echo "$BOOT_JDK" >&6; }
22355 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22356 $as_echo_n "checking Boot JDK version... " >&6; }
22357 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22358 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22359 $as_echo "$BOOT_JDK_VERSION" >&6; }
22360 fi # end check jdk version
22361 fi # end check javac
22362 fi # end check java
22363 fi # end check boot jdk found
22364 fi
22365
22366 done
22367 fi
22368
22369 fi
22370
22371
22372 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22373 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22374 # Do we have a bin/java?
22375 if test ! -x "$BOOT_JDK/bin/java"; then
22376 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22377 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22378 BOOT_JDK_FOUND=no
22379 else
22380 # Do we have a bin/javac?
22381 if test ! -x "$BOOT_JDK/bin/javac"; then
22382 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22383 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22384 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22385 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22386 BOOT_JDK_FOUND=no
22387 else
22388 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22389 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22390
22391 # Extra M4 quote needed to protect [] in grep expression.
22392 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22393 if test "x$FOUND_CORRECT_VERSION" = x; then
22394 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22395 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22396 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22397 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22398 BOOT_JDK_FOUND=no
22399 else
22400 # We're done! :-)
22401 BOOT_JDK_FOUND=yes
22402
22403 # Only process if variable expands to non-empty
22404
22405 if test "x$BOOT_JDK" != x; then
22406 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22407
22408 # Input might be given as Windows format, start by converting to
22409 # unix format.
22410 path="$BOOT_JDK"
22411 new_path=`$CYGPATH -u "$path"`
22412
22413 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22414 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22415 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22416 # "foo.exe" is OK but "foo" is an error.
22417 #
22418 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22419 # It is also a way to make sure we got the proper file name for the real test later on.
22420 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22421 if test "x$test_shortpath" = x; then
22422 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22423 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22424 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22425 fi
22426
22427 # Call helper function which possibly converts this using DOS-style short mode.
22428 # If so, the updated path is stored in $new_path.
22429
22430 input_path="$new_path"
22431 # Check if we need to convert this using DOS-style short mode. If the path
22432 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22433 # take no chances and rewrite it.
22434 # Note: m4 eats our [], so we need to use [ and ] instead.
22435 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22436 if test "x$has_forbidden_chars" != x; then
22437 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22438 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22439 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22440 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22441 # Going to short mode and back again did indeed matter. Since short mode is
22442 # case insensitive, let's make it lowercase to improve readability.
22443 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22444 # Now convert it back to Unix-stile (cygpath)
22445 input_path=`$CYGPATH -u "$shortmode_path"`
22446 new_path="$input_path"
22447 fi
22448 fi
22449
22450 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22451 if test "x$test_cygdrive_prefix" = x; then
22452 # As a simple fix, exclude /usr/bin since it's not a real path.
22453 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22454 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22455 # a path prefixed by /cygdrive for fixpath to work.
22456 new_path="$CYGWIN_ROOT_PATH$input_path"
22457 fi
22458 fi
22459
22460
22461 if test "x$path" != "x$new_path"; then
22462 BOOT_JDK="$new_path"
22463 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22464 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22465 fi
22466
22467 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22468
22469 path="$BOOT_JDK"
22470 has_colon=`$ECHO $path | $GREP ^.:`
22471 new_path="$path"
22472 if test "x$has_colon" = x; then
22473 # Not in mixed or Windows style, start by that.
22474 new_path=`cmd //c echo $path`
22475 fi
22476
22477
22478 input_path="$new_path"
22479 # Check if we need to convert this using DOS-style short mode. If the path
22480 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22481 # take no chances and rewrite it.
22482 # Note: m4 eats our [], so we need to use [ and ] instead.
22483 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22484 if test "x$has_forbidden_chars" != x; then
22485 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22486 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22487 fi
22488
22489
22490 windows_path="$new_path"
22491 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22492 unix_path=`$CYGPATH -u "$windows_path"`
22493 new_path="$unix_path"
22494 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22495 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22496 new_path="$unix_path"
22497 fi
22498
22499 if test "x$path" != "x$new_path"; then
22500 BOOT_JDK="$new_path"
22501 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22502 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22503 fi
22504
22505 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22506 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22507
22508 else
22509 # We're on a unix platform. Hooray! :)
22510 path="$BOOT_JDK"
22511 has_space=`$ECHO "$path" | $GREP " "`
22512 if test "x$has_space" != x; then
22513 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22514 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22515 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22516 fi
22517
22518 # Use eval to expand a potential ~
22519 eval path="$path"
22520 if test ! -f "$path" && test ! -d "$path"; then
22521 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22522 fi
22523
22524 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22525 fi
22526 fi
22527
22528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22529 $as_echo_n "checking for Boot JDK... " >&6; }
22530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22531 $as_echo "$BOOT_JDK" >&6; }
22532 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22533 $as_echo_n "checking Boot JDK version... " >&6; }
22534 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22535 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22536 $as_echo "$BOOT_JDK_VERSION" >&6; }
22537 fi # end check jdk version
22538 fi # end check javac
22539 fi # end check java
22540 fi # end check boot jdk found
22541 fi
22542
22543
22544 if test "x$BOOT_JDK_FOUND" = xno; then
22545 # Now execute the test
22546
22547 if test "x$PROGRAMW6432" != x; then
22548 VIRTUAL_DIR="$PROGRAMW6432/Java"
22549
22550 windows_path="$VIRTUAL_DIR"
22551 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22552 unix_path=`$CYGPATH -u "$windows_path"`
22553 VIRTUAL_DIR="$unix_path"
22554 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22555 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22556 VIRTUAL_DIR="$unix_path"
22557 fi
22558
22559
22560 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22561 BOOT_JDK_SUFFIX=""
22562 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22563 if test "x$ALL_JDKS_FOUND" != x; then
22564 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22565
22566 if test "x$BOOT_JDK_FOUND" = xno; then
22567 # Now execute the test
22568
22569 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22570 if test -d "$BOOT_JDK"; then
22571 BOOT_JDK_FOUND=maybe
22572 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22573 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22574 fi
22575
22576
22577 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22578 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22579 # Do we have a bin/java?
22580 if test ! -x "$BOOT_JDK/bin/java"; then
22581 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22582 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22583 BOOT_JDK_FOUND=no
22584 else
22585 # Do we have a bin/javac?
22586 if test ! -x "$BOOT_JDK/bin/javac"; then
22587 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22588 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22589 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22590 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22591 BOOT_JDK_FOUND=no
22592 else
22593 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22594 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22595
22596 # Extra M4 quote needed to protect [] in grep expression.
22597 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22598 if test "x$FOUND_CORRECT_VERSION" = x; then
22599 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22600 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22601 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22602 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22603 BOOT_JDK_FOUND=no
22604 else
22605 # We're done! :-)
22606 BOOT_JDK_FOUND=yes
22607
22608 # Only process if variable expands to non-empty
22609
22610 if test "x$BOOT_JDK" != x; then
22611 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22612
22613 # Input might be given as Windows format, start by converting to
22614 # unix format.
22615 path="$BOOT_JDK"
22616 new_path=`$CYGPATH -u "$path"`
22617
22618 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22619 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22620 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22621 # "foo.exe" is OK but "foo" is an error.
22622 #
22623 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22624 # It is also a way to make sure we got the proper file name for the real test later on.
22625 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22626 if test "x$test_shortpath" = x; then
22627 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22628 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22629 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22630 fi
22631
22632 # Call helper function which possibly converts this using DOS-style short mode.
22633 # If so, the updated path is stored in $new_path.
22634
22635 input_path="$new_path"
22636 # Check if we need to convert this using DOS-style short mode. If the path
22637 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22638 # take no chances and rewrite it.
22639 # Note: m4 eats our [], so we need to use [ and ] instead.
22640 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22641 if test "x$has_forbidden_chars" != x; then
22642 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22643 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22644 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22645 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22646 # Going to short mode and back again did indeed matter. Since short mode is
22647 # case insensitive, let's make it lowercase to improve readability.
22648 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22649 # Now convert it back to Unix-stile (cygpath)
22650 input_path=`$CYGPATH -u "$shortmode_path"`
22651 new_path="$input_path"
22652 fi
22653 fi
22654
22655 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22656 if test "x$test_cygdrive_prefix" = x; then
22657 # As a simple fix, exclude /usr/bin since it's not a real path.
22658 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22659 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22660 # a path prefixed by /cygdrive for fixpath to work.
22661 new_path="$CYGWIN_ROOT_PATH$input_path"
22662 fi
22663 fi
22664
22665
22666 if test "x$path" != "x$new_path"; then
22667 BOOT_JDK="$new_path"
22668 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22669 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22670 fi
22671
22672 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22673
22674 path="$BOOT_JDK"
22675 has_colon=`$ECHO $path | $GREP ^.:`
22676 new_path="$path"
22677 if test "x$has_colon" = x; then
22678 # Not in mixed or Windows style, start by that.
22679 new_path=`cmd //c echo $path`
22680 fi
22681
22682
22683 input_path="$new_path"
22684 # Check if we need to convert this using DOS-style short mode. If the path
22685 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22686 # take no chances and rewrite it.
22687 # Note: m4 eats our [], so we need to use [ and ] instead.
22688 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22689 if test "x$has_forbidden_chars" != x; then
22690 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22691 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22692 fi
22693
22694
22695 windows_path="$new_path"
22696 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22697 unix_path=`$CYGPATH -u "$windows_path"`
22698 new_path="$unix_path"
22699 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22700 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22701 new_path="$unix_path"
22702 fi
22703
22704 if test "x$path" != "x$new_path"; then
22705 BOOT_JDK="$new_path"
22706 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22707 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22708 fi
22709
22710 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22711 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22712
22713 else
22714 # We're on a unix platform. Hooray! :)
22715 path="$BOOT_JDK"
22716 has_space=`$ECHO "$path" | $GREP " "`
22717 if test "x$has_space" != x; then
22718 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22719 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22720 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22721 fi
22722
22723 # Use eval to expand a potential ~
22724 eval path="$path"
22725 if test ! -f "$path" && test ! -d "$path"; then
22726 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22727 fi
22728
22729 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22730 fi
22731 fi
22732
22733 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22734 $as_echo_n "checking for Boot JDK... " >&6; }
22735 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22736 $as_echo "$BOOT_JDK" >&6; }
22737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22738 $as_echo_n "checking Boot JDK version... " >&6; }
22739 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22740 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22741 $as_echo "$BOOT_JDK_VERSION" >&6; }
22742 fi # end check jdk version
22743 fi # end check javac
22744 fi # end check java
22745 fi # end check boot jdk found
22746 fi
22747
22748 done
22749 fi
22750
22751 fi
22752
22753
22754 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22755 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22756 # Do we have a bin/java?
22757 if test ! -x "$BOOT_JDK/bin/java"; then
22758 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22760 BOOT_JDK_FOUND=no
22761 else
22762 # Do we have a bin/javac?
22763 if test ! -x "$BOOT_JDK/bin/javac"; then
22764 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22765 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22766 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22767 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22768 BOOT_JDK_FOUND=no
22769 else
22770 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22771 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22772
22773 # Extra M4 quote needed to protect [] in grep expression.
22774 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22775 if test "x$FOUND_CORRECT_VERSION" = x; then
22776 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22777 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22778 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22779 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22780 BOOT_JDK_FOUND=no
22781 else
22782 # We're done! :-)
22783 BOOT_JDK_FOUND=yes
22784
22785 # Only process if variable expands to non-empty
22786
22787 if test "x$BOOT_JDK" != x; then
22788 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22789
22790 # Input might be given as Windows format, start by converting to
22791 # unix format.
22792 path="$BOOT_JDK"
22793 new_path=`$CYGPATH -u "$path"`
22794
22795 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22796 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22797 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22798 # "foo.exe" is OK but "foo" is an error.
22799 #
22800 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22801 # It is also a way to make sure we got the proper file name for the real test later on.
22802 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22803 if test "x$test_shortpath" = x; then
22804 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22805 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22806 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22807 fi
22808
22809 # Call helper function which possibly converts this using DOS-style short mode.
22810 # If so, the updated path is stored in $new_path.
22811
22812 input_path="$new_path"
22813 # Check if we need to convert this using DOS-style short mode. If the path
22814 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22815 # take no chances and rewrite it.
22816 # Note: m4 eats our [], so we need to use [ and ] instead.
22817 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22818 if test "x$has_forbidden_chars" != x; then
22819 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22820 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22821 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22822 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22823 # Going to short mode and back again did indeed matter. Since short mode is
22824 # case insensitive, let's make it lowercase to improve readability.
22825 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22826 # Now convert it back to Unix-stile (cygpath)
22827 input_path=`$CYGPATH -u "$shortmode_path"`
22828 new_path="$input_path"
22829 fi
22830 fi
22831
22832 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22833 if test "x$test_cygdrive_prefix" = x; then
22834 # As a simple fix, exclude /usr/bin since it's not a real path.
22835 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22836 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22837 # a path prefixed by /cygdrive for fixpath to work.
22838 new_path="$CYGWIN_ROOT_PATH$input_path"
22839 fi
22840 fi
22841
22842
22843 if test "x$path" != "x$new_path"; then
22844 BOOT_JDK="$new_path"
22845 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22846 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22847 fi
22848
22849 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22850
22851 path="$BOOT_JDK"
22852 has_colon=`$ECHO $path | $GREP ^.:`
22853 new_path="$path"
22854 if test "x$has_colon" = x; then
22855 # Not in mixed or Windows style, start by that.
22856 new_path=`cmd //c echo $path`
22857 fi
22858
22859
22860 input_path="$new_path"
22861 # Check if we need to convert this using DOS-style short mode. If the path
22862 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22863 # take no chances and rewrite it.
22864 # Note: m4 eats our [], so we need to use [ and ] instead.
22865 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22866 if test "x$has_forbidden_chars" != x; then
22867 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22868 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22869 fi
22870
22871
22872 windows_path="$new_path"
22873 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22874 unix_path=`$CYGPATH -u "$windows_path"`
22875 new_path="$unix_path"
22876 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22877 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22878 new_path="$unix_path"
22879 fi
22880
22881 if test "x$path" != "x$new_path"; then
22882 BOOT_JDK="$new_path"
22883 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22884 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22885 fi
22886
22887 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22888 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22889
22890 else
22891 # We're on a unix platform. Hooray! :)
22892 path="$BOOT_JDK"
22893 has_space=`$ECHO "$path" | $GREP " "`
22894 if test "x$has_space" != x; then
22895 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22896 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22897 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22898 fi
22899
22900 # Use eval to expand a potential ~
22901 eval path="$path"
22902 if test ! -f "$path" && test ! -d "$path"; then
22903 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22904 fi
22905
22906 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22907 fi
22908 fi
22909
22910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22911 $as_echo_n "checking for Boot JDK... " >&6; }
22912 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22913 $as_echo "$BOOT_JDK" >&6; }
22914 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22915 $as_echo_n "checking Boot JDK version... " >&6; }
22916 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22918 $as_echo "$BOOT_JDK_VERSION" >&6; }
22919 fi # end check jdk version
22920 fi # end check javac
22921 fi # end check java
22922 fi # end check boot jdk found
22923 fi
22924
22925
22926 if test "x$BOOT_JDK_FOUND" = xno; then
22927 # Now execute the test
22928
22929 if test "x$PROGRAMFILES" != x; then
22930 VIRTUAL_DIR="$PROGRAMFILES/Java"
22931
22932 windows_path="$VIRTUAL_DIR"
22933 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22934 unix_path=`$CYGPATH -u "$windows_path"`
22935 VIRTUAL_DIR="$unix_path"
22936 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22937 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22938 VIRTUAL_DIR="$unix_path"
22939 fi
22940
22941
22942 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22943 BOOT_JDK_SUFFIX=""
22944 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22945 if test "x$ALL_JDKS_FOUND" != x; then
22946 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22947
22948 if test "x$BOOT_JDK_FOUND" = xno; then
22949 # Now execute the test
22950
22951 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22952 if test -d "$BOOT_JDK"; then
22953 BOOT_JDK_FOUND=maybe
22954 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22955 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22956 fi
22957
22958
22959 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22960 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22961 # Do we have a bin/java?
22962 if test ! -x "$BOOT_JDK/bin/java"; then
22963 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22964 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22965 BOOT_JDK_FOUND=no
22966 else
22967 # Do we have a bin/javac?
22968 if test ! -x "$BOOT_JDK/bin/javac"; then
22969 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22970 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22971 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22972 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22973 BOOT_JDK_FOUND=no
22974 else
22975 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22976 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22977
22978 # Extra M4 quote needed to protect [] in grep expression.
22979 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22980 if test "x$FOUND_CORRECT_VERSION" = x; then
22981 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22982 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22983 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22984 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22985 BOOT_JDK_FOUND=no
22986 else
22987 # We're done! :-)
22988 BOOT_JDK_FOUND=yes
22989
22990 # Only process if variable expands to non-empty
22991
22992 if test "x$BOOT_JDK" != x; then
22993 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22994
22995 # Input might be given as Windows format, start by converting to
22996 # unix format.
22997 path="$BOOT_JDK"
22998 new_path=`$CYGPATH -u "$path"`
22999
23000 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23001 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23002 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23003 # "foo.exe" is OK but "foo" is an error.
23004 #
23005 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23006 # It is also a way to make sure we got the proper file name for the real test later on.
23007 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23008 if test "x$test_shortpath" = x; then
23009 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23010 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23011 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23012 fi
23013
23014 # Call helper function which possibly converts this using DOS-style short mode.
23015 # If so, the updated path is stored in $new_path.
23016
23017 input_path="$new_path"
23018 # Check if we need to convert this using DOS-style short mode. If the path
23019 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23020 # take no chances and rewrite it.
23021 # Note: m4 eats our [], so we need to use [ and ] instead.
23022 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23023 if test "x$has_forbidden_chars" != x; then
23024 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23025 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23026 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23027 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23028 # Going to short mode and back again did indeed matter. Since short mode is
23029 # case insensitive, let's make it lowercase to improve readability.
23030 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23031 # Now convert it back to Unix-stile (cygpath)
23032 input_path=`$CYGPATH -u "$shortmode_path"`
23033 new_path="$input_path"
23034 fi
23035 fi
23036
23037 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23038 if test "x$test_cygdrive_prefix" = x; then
23039 # As a simple fix, exclude /usr/bin since it's not a real path.
23040 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23041 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23042 # a path prefixed by /cygdrive for fixpath to work.
23043 new_path="$CYGWIN_ROOT_PATH$input_path"
23044 fi
23045 fi
23046
23047
23048 if test "x$path" != "x$new_path"; then
23049 BOOT_JDK="$new_path"
23050 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23051 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23052 fi
23053
23054 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23055
23056 path="$BOOT_JDK"
23057 has_colon=`$ECHO $path | $GREP ^.:`
23058 new_path="$path"
23059 if test "x$has_colon" = x; then
23060 # Not in mixed or Windows style, start by that.
23061 new_path=`cmd //c echo $path`
23062 fi
23063
23064
23065 input_path="$new_path"
23066 # Check if we need to convert this using DOS-style short mode. If the path
23067 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23068 # take no chances and rewrite it.
23069 # Note: m4 eats our [], so we need to use [ and ] instead.
23070 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23071 if test "x$has_forbidden_chars" != x; then
23072 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23073 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23074 fi
23075
23076
23077 windows_path="$new_path"
23078 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23079 unix_path=`$CYGPATH -u "$windows_path"`
23080 new_path="$unix_path"
23081 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23082 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23083 new_path="$unix_path"
23084 fi
23085
23086 if test "x$path" != "x$new_path"; then
23087 BOOT_JDK="$new_path"
23088 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23089 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23090 fi
23091
23092 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23093 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23094
23095 else
23096 # We're on a unix platform. Hooray! :)
23097 path="$BOOT_JDK"
23098 has_space=`$ECHO "$path" | $GREP " "`
23099 if test "x$has_space" != x; then
23100 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23101 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23102 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23103 fi
23104
23105 # Use eval to expand a potential ~
23106 eval path="$path"
23107 if test ! -f "$path" && test ! -d "$path"; then
23108 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23109 fi
23110
23111 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23112 fi
23113 fi
23114
23115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23116 $as_echo_n "checking for Boot JDK... " >&6; }
23117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23118 $as_echo "$BOOT_JDK" >&6; }
23119 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23120 $as_echo_n "checking Boot JDK version... " >&6; }
23121 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23122 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23123 $as_echo "$BOOT_JDK_VERSION" >&6; }
23124 fi # end check jdk version
23125 fi # end check javac
23126 fi # end check java
23127 fi # end check boot jdk found
23128 fi
23129
23130 done
23131 fi
23132
23133 fi
23134
23135
23136 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23137 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23138 # Do we have a bin/java?
23139 if test ! -x "$BOOT_JDK/bin/java"; then
23140 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23141 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23142 BOOT_JDK_FOUND=no
23143 else
23144 # Do we have a bin/javac?
23145 if test ! -x "$BOOT_JDK/bin/javac"; then
23146 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23147 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23148 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23149 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23150 BOOT_JDK_FOUND=no
23151 else
23152 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23153 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23154
23155 # Extra M4 quote needed to protect [] in grep expression.
23156 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23157 if test "x$FOUND_CORRECT_VERSION" = x; then
23158 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23159 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23160 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23161 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23162 BOOT_JDK_FOUND=no
23163 else
23164 # We're done! :-)
23165 BOOT_JDK_FOUND=yes
23166
23167 # Only process if variable expands to non-empty
23168
23169 if test "x$BOOT_JDK" != x; then
23170 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23171
23172 # Input might be given as Windows format, start by converting to
23173 # unix format.
23174 path="$BOOT_JDK"
23175 new_path=`$CYGPATH -u "$path"`
23176
23177 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23178 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23179 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23180 # "foo.exe" is OK but "foo" is an error.
23181 #
23182 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23183 # It is also a way to make sure we got the proper file name for the real test later on.
23184 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23185 if test "x$test_shortpath" = x; then
23186 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23187 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23188 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23189 fi
23190
23191 # Call helper function which possibly converts this using DOS-style short mode.
23192 # If so, the updated path is stored in $new_path.
23193
23194 input_path="$new_path"
23195 # Check if we need to convert this using DOS-style short mode. If the path
23196 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23197 # take no chances and rewrite it.
23198 # Note: m4 eats our [], so we need to use [ and ] instead.
23199 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23200 if test "x$has_forbidden_chars" != x; then
23201 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23202 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23203 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23204 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23205 # Going to short mode and back again did indeed matter. Since short mode is
23206 # case insensitive, let's make it lowercase to improve readability.
23207 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23208 # Now convert it back to Unix-stile (cygpath)
23209 input_path=`$CYGPATH -u "$shortmode_path"`
23210 new_path="$input_path"
23211 fi
23212 fi
23213
23214 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23215 if test "x$test_cygdrive_prefix" = x; then
23216 # As a simple fix, exclude /usr/bin since it's not a real path.
23217 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23218 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23219 # a path prefixed by /cygdrive for fixpath to work.
23220 new_path="$CYGWIN_ROOT_PATH$input_path"
23221 fi
23222 fi
23223
23224
23225 if test "x$path" != "x$new_path"; then
23226 BOOT_JDK="$new_path"
23227 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23228 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23229 fi
23230
23231 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23232
23233 path="$BOOT_JDK"
23234 has_colon=`$ECHO $path | $GREP ^.:`
23235 new_path="$path"
23236 if test "x$has_colon" = x; then
23237 # Not in mixed or Windows style, start by that.
23238 new_path=`cmd //c echo $path`
23239 fi
23240
23241
23242 input_path="$new_path"
23243 # Check if we need to convert this using DOS-style short mode. If the path
23244 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23245 # take no chances and rewrite it.
23246 # Note: m4 eats our [], so we need to use [ and ] instead.
23247 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23248 if test "x$has_forbidden_chars" != x; then
23249 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23250 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23251 fi
23252
23253
23254 windows_path="$new_path"
23255 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23256 unix_path=`$CYGPATH -u "$windows_path"`
23257 new_path="$unix_path"
23258 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23259 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23260 new_path="$unix_path"
23261 fi
23262
23263 if test "x$path" != "x$new_path"; then
23264 BOOT_JDK="$new_path"
23265 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23266 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23267 fi
23268
23269 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23270 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23271
23272 else
23273 # We're on a unix platform. Hooray! :)
23274 path="$BOOT_JDK"
23275 has_space=`$ECHO "$path" | $GREP " "`
23276 if test "x$has_space" != x; then
23277 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23278 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23279 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23280 fi
23281
23282 # Use eval to expand a potential ~
23283 eval path="$path"
23284 if test ! -f "$path" && test ! -d "$path"; then
23285 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23286 fi
23287
23288 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23289 fi
23290 fi
23291
23292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23293 $as_echo_n "checking for Boot JDK... " >&6; }
23294 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23295 $as_echo "$BOOT_JDK" >&6; }
23296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23297 $as_echo_n "checking Boot JDK version... " >&6; }
23298 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23299 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23300 $as_echo "$BOOT_JDK_VERSION" >&6; }
23301 fi # end check jdk version
23302 fi # end check javac
23303 fi # end check java
23304 fi # end check boot jdk found
23305 fi
23306
23307
23308 if test "x$BOOT_JDK_FOUND" = xno; then
23309 # Now execute the test
23310
23311 if test "x$ProgramFiles" != x; then
23312 VIRTUAL_DIR="$ProgramFiles/Java"
23313
23314 windows_path="$VIRTUAL_DIR"
23315 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23316 unix_path=`$CYGPATH -u "$windows_path"`
23317 VIRTUAL_DIR="$unix_path"
23318 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23319 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23320 VIRTUAL_DIR="$unix_path"
23321 fi
23322
23323
23324 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23325 BOOT_JDK_SUFFIX=""
23326 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23327 if test "x$ALL_JDKS_FOUND" != x; then
23328 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23329
23330 if test "x$BOOT_JDK_FOUND" = xno; then
23331 # Now execute the test
23332
23333 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23334 if test -d "$BOOT_JDK"; then
23335 BOOT_JDK_FOUND=maybe
23336 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23337 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23338 fi
23339
23340
23341 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23342 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23343 # Do we have a bin/java?
23344 if test ! -x "$BOOT_JDK/bin/java"; then
23345 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23346 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23347 BOOT_JDK_FOUND=no
23348 else
23349 # Do we have a bin/javac?
23350 if test ! -x "$BOOT_JDK/bin/javac"; then
23351 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23352 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23353 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23354 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23355 BOOT_JDK_FOUND=no
23356 else
23357 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23358 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23359
23360 # Extra M4 quote needed to protect [] in grep expression.
23361 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23362 if test "x$FOUND_CORRECT_VERSION" = x; then
23363 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23364 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23365 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23366 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23367 BOOT_JDK_FOUND=no
23368 else
23369 # We're done! :-)
23370 BOOT_JDK_FOUND=yes
23371
23372 # Only process if variable expands to non-empty
23373
23374 if test "x$BOOT_JDK" != x; then
23375 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23376
23377 # Input might be given as Windows format, start by converting to
23378 # unix format.
23379 path="$BOOT_JDK"
23380 new_path=`$CYGPATH -u "$path"`
23381
23382 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23383 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23384 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23385 # "foo.exe" is OK but "foo" is an error.
23386 #
23387 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23388 # It is also a way to make sure we got the proper file name for the real test later on.
23389 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23390 if test "x$test_shortpath" = x; then
23391 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23392 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23393 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23394 fi
23395
23396 # Call helper function which possibly converts this using DOS-style short mode.
23397 # If so, the updated path is stored in $new_path.
23398
23399 input_path="$new_path"
23400 # Check if we need to convert this using DOS-style short mode. If the path
23401 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23402 # take no chances and rewrite it.
23403 # Note: m4 eats our [], so we need to use [ and ] instead.
23404 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23405 if test "x$has_forbidden_chars" != x; then
23406 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23407 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23408 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23409 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23410 # Going to short mode and back again did indeed matter. Since short mode is
23411 # case insensitive, let's make it lowercase to improve readability.
23412 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23413 # Now convert it back to Unix-stile (cygpath)
23414 input_path=`$CYGPATH -u "$shortmode_path"`
23415 new_path="$input_path"
23416 fi
23417 fi
23418
23419 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23420 if test "x$test_cygdrive_prefix" = x; then
23421 # As a simple fix, exclude /usr/bin since it's not a real path.
23422 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23423 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23424 # a path prefixed by /cygdrive for fixpath to work.
23425 new_path="$CYGWIN_ROOT_PATH$input_path"
23426 fi
23427 fi
23428
23429
23430 if test "x$path" != "x$new_path"; then
23431 BOOT_JDK="$new_path"
23432 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23433 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23434 fi
23435
23436 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23437
23438 path="$BOOT_JDK"
23439 has_colon=`$ECHO $path | $GREP ^.:`
23440 new_path="$path"
23441 if test "x$has_colon" = x; then
23442 # Not in mixed or Windows style, start by that.
23443 new_path=`cmd //c echo $path`
23444 fi
23445
23446
23447 input_path="$new_path"
23448 # Check if we need to convert this using DOS-style short mode. If the path
23449 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23450 # take no chances and rewrite it.
23451 # Note: m4 eats our [], so we need to use [ and ] instead.
23452 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23453 if test "x$has_forbidden_chars" != x; then
23454 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23455 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23456 fi
23457
23458
23459 windows_path="$new_path"
23460 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23461 unix_path=`$CYGPATH -u "$windows_path"`
23462 new_path="$unix_path"
23463 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23464 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23465 new_path="$unix_path"
23466 fi
23467
23468 if test "x$path" != "x$new_path"; then
23469 BOOT_JDK="$new_path"
23470 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23471 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23472 fi
23473
23474 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23475 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23476
23477 else
23478 # We're on a unix platform. Hooray! :)
23479 path="$BOOT_JDK"
23480 has_space=`$ECHO "$path" | $GREP " "`
23481 if test "x$has_space" != x; then
23482 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23483 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23484 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23485 fi
23486
23487 # Use eval to expand a potential ~
23488 eval path="$path"
23489 if test ! -f "$path" && test ! -d "$path"; then
23490 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23491 fi
23492
23493 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23494 fi
23495 fi
23496
23497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23498 $as_echo_n "checking for Boot JDK... " >&6; }
23499 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23500 $as_echo "$BOOT_JDK" >&6; }
23501 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23502 $as_echo_n "checking Boot JDK version... " >&6; }
23503 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23504 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23505 $as_echo "$BOOT_JDK_VERSION" >&6; }
23506 fi # end check jdk version
23507 fi # end check javac
23508 fi # end check java
23509 fi # end check boot jdk found
23510 fi
23511
23512 done
23513 fi
23514
23515 fi
23516
23517
23518 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23519 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23520 # Do we have a bin/java?
23521 if test ! -x "$BOOT_JDK/bin/java"; then
23522 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23523 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23524 BOOT_JDK_FOUND=no
23525 else
23526 # Do we have a bin/javac?
23527 if test ! -x "$BOOT_JDK/bin/javac"; then
23528 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23529 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23530 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23531 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23532 BOOT_JDK_FOUND=no
23533 else
23534 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23535 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23536
23537 # Extra M4 quote needed to protect [] in grep expression.
23538 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23539 if test "x$FOUND_CORRECT_VERSION" = x; then
23540 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23541 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23542 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23543 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23544 BOOT_JDK_FOUND=no
23545 else
23546 # We're done! :-)
23547 BOOT_JDK_FOUND=yes
23548
23549 # Only process if variable expands to non-empty
23550
23551 if test "x$BOOT_JDK" != x; then
23552 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23553
23554 # Input might be given as Windows format, start by converting to
23555 # unix format.
23556 path="$BOOT_JDK"
23557 new_path=`$CYGPATH -u "$path"`
23558
23559 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23560 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23561 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23562 # "foo.exe" is OK but "foo" is an error.
23563 #
23564 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23565 # It is also a way to make sure we got the proper file name for the real test later on.
23566 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23567 if test "x$test_shortpath" = x; then
23568 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23569 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23570 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23571 fi
23572
23573 # Call helper function which possibly converts this using DOS-style short mode.
23574 # If so, the updated path is stored in $new_path.
23575
23576 input_path="$new_path"
23577 # Check if we need to convert this using DOS-style short mode. If the path
23578 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23579 # take no chances and rewrite it.
23580 # Note: m4 eats our [], so we need to use [ and ] instead.
23581 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23582 if test "x$has_forbidden_chars" != x; then
23583 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23584 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23585 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23586 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23587 # Going to short mode and back again did indeed matter. Since short mode is
23588 # case insensitive, let's make it lowercase to improve readability.
23589 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23590 # Now convert it back to Unix-stile (cygpath)
23591 input_path=`$CYGPATH -u "$shortmode_path"`
23592 new_path="$input_path"
23593 fi
23594 fi
23595
23596 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23597 if test "x$test_cygdrive_prefix" = x; then
23598 # As a simple fix, exclude /usr/bin since it's not a real path.
23599 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23600 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23601 # a path prefixed by /cygdrive for fixpath to work.
23602 new_path="$CYGWIN_ROOT_PATH$input_path"
23603 fi
23604 fi
23605
23606
23607 if test "x$path" != "x$new_path"; then
23608 BOOT_JDK="$new_path"
23609 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23610 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23611 fi
23612
23613 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23614
23615 path="$BOOT_JDK"
23616 has_colon=`$ECHO $path | $GREP ^.:`
23617 new_path="$path"
23618 if test "x$has_colon" = x; then
23619 # Not in mixed or Windows style, start by that.
23620 new_path=`cmd //c echo $path`
23621 fi
23622
23623
23624 input_path="$new_path"
23625 # Check if we need to convert this using DOS-style short mode. If the path
23626 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23627 # take no chances and rewrite it.
23628 # Note: m4 eats our [], so we need to use [ and ] instead.
23629 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23630 if test "x$has_forbidden_chars" != x; then
23631 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23632 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23633 fi
23634
23635
23636 windows_path="$new_path"
23637 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23638 unix_path=`$CYGPATH -u "$windows_path"`
23639 new_path="$unix_path"
23640 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23641 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23642 new_path="$unix_path"
23643 fi
23644
23645 if test "x$path" != "x$new_path"; then
23646 BOOT_JDK="$new_path"
23647 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23648 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23649 fi
23650
23651 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23652 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23653
23654 else
23655 # We're on a unix platform. Hooray! :)
23656 path="$BOOT_JDK"
23657 has_space=`$ECHO "$path" | $GREP " "`
23658 if test "x$has_space" != x; then
23659 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23660 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23661 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23662 fi
23663
23664 # Use eval to expand a potential ~
23665 eval path="$path"
23666 if test ! -f "$path" && test ! -d "$path"; then
23667 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23668 fi
23669
23670 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23671 fi
23672 fi
23673
23674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23675 $as_echo_n "checking for Boot JDK... " >&6; }
23676 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23677 $as_echo "$BOOT_JDK" >&6; }
23678 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23679 $as_echo_n "checking Boot JDK version... " >&6; }
23680 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23681 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23682 $as_echo "$BOOT_JDK_VERSION" >&6; }
23683 fi # end check jdk version
23684 fi # end check javac
23685 fi # end check java
23686 fi # end check boot jdk found
23687 fi
23688
23689
23690 if test "x$BOOT_JDK_FOUND" = xno; then
23691 # Now execute the test
23692
23693 BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23694 BOOT_JDK_SUFFIX=""
23695 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23696 if test "x$ALL_JDKS_FOUND" != x; then
23697 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23698
23699 if test "x$BOOT_JDK_FOUND" = xno; then
23700 # Now execute the test
23701
23702 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23703 if test -d "$BOOT_JDK"; then
23704 BOOT_JDK_FOUND=maybe
23705 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23706 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23707 fi
23708
23709
23710 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23711 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23712 # Do we have a bin/java?
23713 if test ! -x "$BOOT_JDK/bin/java"; then
23714 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23715 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23716 BOOT_JDK_FOUND=no
23717 else
23718 # Do we have a bin/javac?
23719 if test ! -x "$BOOT_JDK/bin/javac"; then
23720 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23721 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23722 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23723 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23724 BOOT_JDK_FOUND=no
23725 else
23726 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23727 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23728
23729 # Extra M4 quote needed to protect [] in grep expression.
23730 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23731 if test "x$FOUND_CORRECT_VERSION" = x; then
23732 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23733 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23734 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23735 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23736 BOOT_JDK_FOUND=no
23737 else
23738 # We're done! :-)
23739 BOOT_JDK_FOUND=yes
23740
23741 # Only process if variable expands to non-empty
23742
23743 if test "x$BOOT_JDK" != x; then
23744 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23745
23746 # Input might be given as Windows format, start by converting to
23747 # unix format.
23748 path="$BOOT_JDK"
23749 new_path=`$CYGPATH -u "$path"`
23750
23751 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23752 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23753 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23754 # "foo.exe" is OK but "foo" is an error.
23755 #
23756 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23757 # It is also a way to make sure we got the proper file name for the real test later on.
23758 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23759 if test "x$test_shortpath" = x; then
23760 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23761 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23762 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23763 fi
23764
23765 # Call helper function which possibly converts this using DOS-style short mode.
23766 # If so, the updated path is stored in $new_path.
23767
23768 input_path="$new_path"
23769 # Check if we need to convert this using DOS-style short mode. If the path
23770 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23771 # take no chances and rewrite it.
23772 # Note: m4 eats our [], so we need to use [ and ] instead.
23773 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23774 if test "x$has_forbidden_chars" != x; then
23775 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23776 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23777 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23778 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23779 # Going to short mode and back again did indeed matter. Since short mode is
23780 # case insensitive, let's make it lowercase to improve readability.
23781 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23782 # Now convert it back to Unix-stile (cygpath)
23783 input_path=`$CYGPATH -u "$shortmode_path"`
23784 new_path="$input_path"
23785 fi
23786 fi
23787
23788 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23789 if test "x$test_cygdrive_prefix" = x; then
23790 # As a simple fix, exclude /usr/bin since it's not a real path.
23791 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23792 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23793 # a path prefixed by /cygdrive for fixpath to work.
23794 new_path="$CYGWIN_ROOT_PATH$input_path"
23795 fi
23796 fi
23797
23798
23799 if test "x$path" != "x$new_path"; then
23800 BOOT_JDK="$new_path"
23801 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23802 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23803 fi
23804
23805 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23806
23807 path="$BOOT_JDK"
23808 has_colon=`$ECHO $path | $GREP ^.:`
23809 new_path="$path"
23810 if test "x$has_colon" = x; then
23811 # Not in mixed or Windows style, start by that.
23812 new_path=`cmd //c echo $path`
23813 fi
23814
23815
23816 input_path="$new_path"
23817 # Check if we need to convert this using DOS-style short mode. If the path
23818 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23819 # take no chances and rewrite it.
23820 # Note: m4 eats our [], so we need to use [ and ] instead.
23821 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23822 if test "x$has_forbidden_chars" != x; then
23823 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23824 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23825 fi
23826
23827
23828 windows_path="$new_path"
23829 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23830 unix_path=`$CYGPATH -u "$windows_path"`
23831 new_path="$unix_path"
23832 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23833 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23834 new_path="$unix_path"
23835 fi
23836
23837 if test "x$path" != "x$new_path"; then
23838 BOOT_JDK="$new_path"
23839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23840 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23841 fi
23842
23843 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23844 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23845
23846 else
23847 # We're on a unix platform. Hooray! :)
23848 path="$BOOT_JDK"
23849 has_space=`$ECHO "$path" | $GREP " "`
23850 if test "x$has_space" != x; then
23851 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23852 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23853 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23854 fi
23855
23856 # Use eval to expand a potential ~
23857 eval path="$path"
23858 if test ! -f "$path" && test ! -d "$path"; then
23859 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23860 fi
23861
23862 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23863 fi
23864 fi
23865
23866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23867 $as_echo_n "checking for Boot JDK... " >&6; }
23868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23869 $as_echo "$BOOT_JDK" >&6; }
23870 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23871 $as_echo_n "checking Boot JDK version... " >&6; }
23872 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23874 $as_echo "$BOOT_JDK_VERSION" >&6; }
23875 fi # end check jdk version
23876 fi # end check javac
23877 fi # end check java
23878 fi # end check boot jdk found
23879 fi
23880
23881 done
23882 fi
23883
23884
23885 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23886 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23887 # Do we have a bin/java?
23888 if test ! -x "$BOOT_JDK/bin/java"; then
23889 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23890 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23891 BOOT_JDK_FOUND=no
23892 else
23893 # Do we have a bin/javac?
23894 if test ! -x "$BOOT_JDK/bin/javac"; then
23895 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23896 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23897 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23898 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23899 BOOT_JDK_FOUND=no
23900 else
23901 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23902 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23903
23904 # Extra M4 quote needed to protect [] in grep expression.
23905 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23906 if test "x$FOUND_CORRECT_VERSION" = x; then
23907 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23908 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23909 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23910 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23911 BOOT_JDK_FOUND=no
23912 else
23913 # We're done! :-)
23914 BOOT_JDK_FOUND=yes
23915
23916 # Only process if variable expands to non-empty
23917
23918 if test "x$BOOT_JDK" != x; then
23919 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23920
23921 # Input might be given as Windows format, start by converting to
23922 # unix format.
23923 path="$BOOT_JDK"
23924 new_path=`$CYGPATH -u "$path"`
23925
23926 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23927 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23928 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23929 # "foo.exe" is OK but "foo" is an error.
23930 #
23931 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23932 # It is also a way to make sure we got the proper file name for the real test later on.
23933 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23934 if test "x$test_shortpath" = x; then
23935 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23936 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23937 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23938 fi
23939
23940 # Call helper function which possibly converts this using DOS-style short mode.
23941 # If so, the updated path is stored in $new_path.
23942
23943 input_path="$new_path"
23944 # Check if we need to convert this using DOS-style short mode. If the path
23945 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23946 # take no chances and rewrite it.
23947 # Note: m4 eats our [], so we need to use [ and ] instead.
23948 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23949 if test "x$has_forbidden_chars" != x; then
23950 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23951 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23952 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23953 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23954 # Going to short mode and back again did indeed matter. Since short mode is
23955 # case insensitive, let's make it lowercase to improve readability.
23956 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23957 # Now convert it back to Unix-stile (cygpath)
23958 input_path=`$CYGPATH -u "$shortmode_path"`
23959 new_path="$input_path"
23960 fi
23961 fi
23962
23963 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23964 if test "x$test_cygdrive_prefix" = x; then
23965 # As a simple fix, exclude /usr/bin since it's not a real path.
23966 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23967 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23968 # a path prefixed by /cygdrive for fixpath to work.
23969 new_path="$CYGWIN_ROOT_PATH$input_path"
23970 fi
23971 fi
23972
23973
23974 if test "x$path" != "x$new_path"; then
23975 BOOT_JDK="$new_path"
23976 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23977 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23978 fi
23979
23980 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23981
23982 path="$BOOT_JDK"
23983 has_colon=`$ECHO $path | $GREP ^.:`
23984 new_path="$path"
23985 if test "x$has_colon" = x; then
23986 # Not in mixed or Windows style, start by that.
23987 new_path=`cmd //c echo $path`
23988 fi
23989
23990
23991 input_path="$new_path"
23992 # Check if we need to convert this using DOS-style short mode. If the path
23993 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23994 # take no chances and rewrite it.
23995 # Note: m4 eats our [], so we need to use [ and ] instead.
23996 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23997 if test "x$has_forbidden_chars" != x; then
23998 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23999 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24000 fi
24001
24002
24003 windows_path="$new_path"
24004 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24005 unix_path=`$CYGPATH -u "$windows_path"`
24006 new_path="$unix_path"
24007 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24008 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24009 new_path="$unix_path"
24010 fi
24011
24012 if test "x$path" != "x$new_path"; then
24013 BOOT_JDK="$new_path"
24014 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24015 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24016 fi
24017
24018 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24019 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24020
24021 else
24022 # We're on a unix platform. Hooray! :)
24023 path="$BOOT_JDK"
24024 has_space=`$ECHO "$path" | $GREP " "`
24025 if test "x$has_space" != x; then
24026 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24027 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24028 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24029 fi
24030
24031 # Use eval to expand a potential ~
24032 eval path="$path"
24033 if test ! -f "$path" && test ! -d "$path"; then
24034 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24035 fi
24036
24037 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24038 fi
24039 fi
24040
24041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24042 $as_echo_n "checking for Boot JDK... " >&6; }
24043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24044 $as_echo "$BOOT_JDK" >&6; }
24045 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24046 $as_echo_n "checking Boot JDK version... " >&6; }
24047 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24048 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24049 $as_echo "$BOOT_JDK_VERSION" >&6; }
24050 fi # end check jdk version
24051 fi # end check javac
24052 fi # end check java
24053 fi # end check boot jdk found
24054 fi
24055
24056 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
24057
24058 if test "x$BOOT_JDK_FOUND" = xno; then
24059 # Now execute the test
24060
24061 BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
24062 BOOT_JDK_SUFFIX="/Contents/Home"
24063 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24064 if test "x$ALL_JDKS_FOUND" != x; then
24065 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24066
24067 if test "x$BOOT_JDK_FOUND" = xno; then
24068 # Now execute the test
24069
24070 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24071 if test -d "$BOOT_JDK"; then
24072 BOOT_JDK_FOUND=maybe
24073 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24074 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24075 fi
24076
24077
24078 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24079 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24080 # Do we have a bin/java?
24081 if test ! -x "$BOOT_JDK/bin/java"; then
24082 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24083 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24084 BOOT_JDK_FOUND=no
24085 else
24086 # Do we have a bin/javac?
24087 if test ! -x "$BOOT_JDK/bin/javac"; then
24088 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24089 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24090 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24091 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24092 BOOT_JDK_FOUND=no
24093 else
24094 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24095 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24096
24097 # Extra M4 quote needed to protect [] in grep expression.
24098 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24099 if test "x$FOUND_CORRECT_VERSION" = x; then
24100 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24101 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24102 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24103 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24104 BOOT_JDK_FOUND=no
24105 else
24106 # We're done! :-)
24107 BOOT_JDK_FOUND=yes
24108
24109 # Only process if variable expands to non-empty
24110
24111 if test "x$BOOT_JDK" != x; then
24112 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24113
24114 # Input might be given as Windows format, start by converting to
24115 # unix format.
24116 path="$BOOT_JDK"
24117 new_path=`$CYGPATH -u "$path"`
24118
24119 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24120 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24121 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24122 # "foo.exe" is OK but "foo" is an error.
24123 #
24124 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24125 # It is also a way to make sure we got the proper file name for the real test later on.
24126 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24127 if test "x$test_shortpath" = x; then
24128 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24129 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24130 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24131 fi
24132
24133 # Call helper function which possibly converts this using DOS-style short mode.
24134 # If so, the updated path is stored in $new_path.
24135
24136 input_path="$new_path"
24137 # Check if we need to convert this using DOS-style short mode. If the path
24138 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24139 # take no chances and rewrite it.
24140 # Note: m4 eats our [], so we need to use [ and ] instead.
24141 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24142 if test "x$has_forbidden_chars" != x; then
24143 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24144 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24145 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24146 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24147 # Going to short mode and back again did indeed matter. Since short mode is
24148 # case insensitive, let's make it lowercase to improve readability.
24149 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24150 # Now convert it back to Unix-stile (cygpath)
24151 input_path=`$CYGPATH -u "$shortmode_path"`
24152 new_path="$input_path"
24153 fi
24154 fi
24155
24156 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24157 if test "x$test_cygdrive_prefix" = x; then
24158 # As a simple fix, exclude /usr/bin since it's not a real path.
24159 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24160 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24161 # a path prefixed by /cygdrive for fixpath to work.
24162 new_path="$CYGWIN_ROOT_PATH$input_path"
24163 fi
24164 fi
24165
24166
24167 if test "x$path" != "x$new_path"; then
24168 BOOT_JDK="$new_path"
24169 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24170 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24171 fi
24172
24173 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24174
24175 path="$BOOT_JDK"
24176 has_colon=`$ECHO $path | $GREP ^.:`
24177 new_path="$path"
24178 if test "x$has_colon" = x; then
24179 # Not in mixed or Windows style, start by that.
24180 new_path=`cmd //c echo $path`
24181 fi
24182
24183
24184 input_path="$new_path"
24185 # Check if we need to convert this using DOS-style short mode. If the path
24186 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24187 # take no chances and rewrite it.
24188 # Note: m4 eats our [], so we need to use [ and ] instead.
24189 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24190 if test "x$has_forbidden_chars" != x; then
24191 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24192 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24193 fi
24194
24195
24196 windows_path="$new_path"
24197 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24198 unix_path=`$CYGPATH -u "$windows_path"`
24199 new_path="$unix_path"
24200 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24201 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24202 new_path="$unix_path"
24203 fi
24204
24205 if test "x$path" != "x$new_path"; then
24206 BOOT_JDK="$new_path"
24207 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24208 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24209 fi
24210
24211 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24212 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24213
24214 else
24215 # We're on a unix platform. Hooray! :)
24216 path="$BOOT_JDK"
24217 has_space=`$ECHO "$path" | $GREP " "`
24218 if test "x$has_space" != x; then
24219 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24220 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24221 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24222 fi
24223
24224 # Use eval to expand a potential ~
24225 eval path="$path"
24226 if test ! -f "$path" && test ! -d "$path"; then
24227 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24228 fi
24229
24230 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24231 fi
24232 fi
24233
24234 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24235 $as_echo_n "checking for Boot JDK... " >&6; }
24236 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24237 $as_echo "$BOOT_JDK" >&6; }
24238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24239 $as_echo_n "checking Boot JDK version... " >&6; }
24240 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24241 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24242 $as_echo "$BOOT_JDK_VERSION" >&6; }
24243 fi # end check jdk version
24244 fi # end check javac
24245 fi # end check java
24246 fi # end check boot jdk found
24247 fi
24248
24249 done
24250 fi
24251
24252
24253 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24254 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24255 # Do we have a bin/java?
24256 if test ! -x "$BOOT_JDK/bin/java"; then
24257 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24258 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24259 BOOT_JDK_FOUND=no
24260 else
24261 # Do we have a bin/javac?
24262 if test ! -x "$BOOT_JDK/bin/javac"; then
24263 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24264 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24265 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24266 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24267 BOOT_JDK_FOUND=no
24268 else
24269 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24270 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24271
24272 # Extra M4 quote needed to protect [] in grep expression.
24273 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24274 if test "x$FOUND_CORRECT_VERSION" = x; then
24275 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24276 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24277 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24278 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24279 BOOT_JDK_FOUND=no
24280 else
24281 # We're done! :-)
24282 BOOT_JDK_FOUND=yes
24283
24284 # Only process if variable expands to non-empty
24285
24286 if test "x$BOOT_JDK" != x; then
24287 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24288
24289 # Input might be given as Windows format, start by converting to
24290 # unix format.
24291 path="$BOOT_JDK"
24292 new_path=`$CYGPATH -u "$path"`
24293
24294 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24295 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24296 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24297 # "foo.exe" is OK but "foo" is an error.
24298 #
24299 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24300 # It is also a way to make sure we got the proper file name for the real test later on.
24301 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24302 if test "x$test_shortpath" = x; then
24303 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24304 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24305 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24306 fi
24307
24308 # Call helper function which possibly converts this using DOS-style short mode.
24309 # If so, the updated path is stored in $new_path.
24310
24311 input_path="$new_path"
24312 # Check if we need to convert this using DOS-style short mode. If the path
24313 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24314 # take no chances and rewrite it.
24315 # Note: m4 eats our [], so we need to use [ and ] instead.
24316 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24317 if test "x$has_forbidden_chars" != x; then
24318 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24319 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24320 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24321 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24322 # Going to short mode and back again did indeed matter. Since short mode is
24323 # case insensitive, let's make it lowercase to improve readability.
24324 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24325 # Now convert it back to Unix-stile (cygpath)
24326 input_path=`$CYGPATH -u "$shortmode_path"`
24327 new_path="$input_path"
24328 fi
24329 fi
24330
24331 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24332 if test "x$test_cygdrive_prefix" = x; then
24333 # As a simple fix, exclude /usr/bin since it's not a real path.
24334 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24335 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24336 # a path prefixed by /cygdrive for fixpath to work.
24337 new_path="$CYGWIN_ROOT_PATH$input_path"
24338 fi
24339 fi
24340
24341
24342 if test "x$path" != "x$new_path"; then
24343 BOOT_JDK="$new_path"
24344 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24345 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24346 fi
24347
24348 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24349
24350 path="$BOOT_JDK"
24351 has_colon=`$ECHO $path | $GREP ^.:`
24352 new_path="$path"
24353 if test "x$has_colon" = x; then
24354 # Not in mixed or Windows style, start by that.
24355 new_path=`cmd //c echo $path`
24356 fi
24357
24358
24359 input_path="$new_path"
24360 # Check if we need to convert this using DOS-style short mode. If the path
24361 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24362 # take no chances and rewrite it.
24363 # Note: m4 eats our [], so we need to use [ and ] instead.
24364 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24365 if test "x$has_forbidden_chars" != x; then
24366 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24367 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24368 fi
24369
24370
24371 windows_path="$new_path"
24372 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24373 unix_path=`$CYGPATH -u "$windows_path"`
24374 new_path="$unix_path"
24375 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24376 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24377 new_path="$unix_path"
24378 fi
24379
24380 if test "x$path" != "x$new_path"; then
24381 BOOT_JDK="$new_path"
24382 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24383 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24384 fi
24385
24386 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24387 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24388
24389 else
24390 # We're on a unix platform. Hooray! :)
24391 path="$BOOT_JDK"
24392 has_space=`$ECHO "$path" | $GREP " "`
24393 if test "x$has_space" != x; then
24394 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24395 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24396 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24397 fi
24398
24399 # Use eval to expand a potential ~
24400 eval path="$path"
24401 if test ! -f "$path" && test ! -d "$path"; then
24402 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24403 fi
24404
24405 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24406 fi
24407 fi
24408
24409 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24410 $as_echo_n "checking for Boot JDK... " >&6; }
24411 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24412 $as_echo "$BOOT_JDK" >&6; }
24413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24414 $as_echo_n "checking Boot JDK version... " >&6; }
24415 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24416 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24417 $as_echo "$BOOT_JDK_VERSION" >&6; }
24418 fi # end check jdk version
24419 fi # end check javac
24420 fi # end check java
24421 fi # end check boot jdk found
24422 fi
24423
24424
24425 if test "x$BOOT_JDK_FOUND" = xno; then
24426 # Now execute the test
24427
24428 BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24429 BOOT_JDK_SUFFIX="/Contents/Home"
24430 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24431 if test "x$ALL_JDKS_FOUND" != x; then
24432 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24433
24434 if test "x$BOOT_JDK_FOUND" = xno; then
24435 # Now execute the test
24436
24437 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24438 if test -d "$BOOT_JDK"; then
24439 BOOT_JDK_FOUND=maybe
24440 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24441 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24442 fi
24443
24444
24445 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24446 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24447 # Do we have a bin/java?
24448 if test ! -x "$BOOT_JDK/bin/java"; then
24449 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24450 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24451 BOOT_JDK_FOUND=no
24452 else
24453 # Do we have a bin/javac?
24454 if test ! -x "$BOOT_JDK/bin/javac"; then
24455 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24456 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24457 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24458 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24459 BOOT_JDK_FOUND=no
24460 else
24461 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24462 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24463
24464 # Extra M4 quote needed to protect [] in grep expression.
24465 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24466 if test "x$FOUND_CORRECT_VERSION" = x; then
24467 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24468 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24469 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24470 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24471 BOOT_JDK_FOUND=no
24472 else
24473 # We're done! :-)
24474 BOOT_JDK_FOUND=yes
24475
24476 # Only process if variable expands to non-empty
24477
24478 if test "x$BOOT_JDK" != x; then
24479 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24480
24481 # Input might be given as Windows format, start by converting to
24482 # unix format.
24483 path="$BOOT_JDK"
24484 new_path=`$CYGPATH -u "$path"`
24485
24486 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24487 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24488 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24489 # "foo.exe" is OK but "foo" is an error.
24490 #
24491 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24492 # It is also a way to make sure we got the proper file name for the real test later on.
24493 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24494 if test "x$test_shortpath" = x; then
24495 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24496 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24497 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24498 fi
24499
24500 # Call helper function which possibly converts this using DOS-style short mode.
24501 # If so, the updated path is stored in $new_path.
24502
24503 input_path="$new_path"
24504 # Check if we need to convert this using DOS-style short mode. If the path
24505 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24506 # take no chances and rewrite it.
24507 # Note: m4 eats our [], so we need to use [ and ] instead.
24508 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24509 if test "x$has_forbidden_chars" != x; then
24510 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24511 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24512 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24513 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24514 # Going to short mode and back again did indeed matter. Since short mode is
24515 # case insensitive, let's make it lowercase to improve readability.
24516 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24517 # Now convert it back to Unix-stile (cygpath)
24518 input_path=`$CYGPATH -u "$shortmode_path"`
24519 new_path="$input_path"
24520 fi
24521 fi
24522
24523 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24524 if test "x$test_cygdrive_prefix" = x; then
24525 # As a simple fix, exclude /usr/bin since it's not a real path.
24526 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24527 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24528 # a path prefixed by /cygdrive for fixpath to work.
24529 new_path="$CYGWIN_ROOT_PATH$input_path"
24530 fi
24531 fi
24532
24533
24534 if test "x$path" != "x$new_path"; then
24535 BOOT_JDK="$new_path"
24536 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24537 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24538 fi
24539
24540 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24541
24542 path="$BOOT_JDK"
24543 has_colon=`$ECHO $path | $GREP ^.:`
24544 new_path="$path"
24545 if test "x$has_colon" = x; then
24546 # Not in mixed or Windows style, start by that.
24547 new_path=`cmd //c echo $path`
24548 fi
24549
24550
24551 input_path="$new_path"
24552 # Check if we need to convert this using DOS-style short mode. If the path
24553 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24554 # take no chances and rewrite it.
24555 # Note: m4 eats our [], so we need to use [ and ] instead.
24556 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24557 if test "x$has_forbidden_chars" != x; then
24558 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24559 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24560 fi
24561
24562
24563 windows_path="$new_path"
24564 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24565 unix_path=`$CYGPATH -u "$windows_path"`
24566 new_path="$unix_path"
24567 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24568 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24569 new_path="$unix_path"
24570 fi
24571
24572 if test "x$path" != "x$new_path"; then
24573 BOOT_JDK="$new_path"
24574 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24575 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24576 fi
24577
24578 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24579 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24580
24581 else
24582 # We're on a unix platform. Hooray! :)
24583 path="$BOOT_JDK"
24584 has_space=`$ECHO "$path" | $GREP " "`
24585 if test "x$has_space" != x; then
24586 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24587 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24588 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24589 fi
24590
24591 # Use eval to expand a potential ~
24592 eval path="$path"
24593 if test ! -f "$path" && test ! -d "$path"; then
24594 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24595 fi
24596
24597 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24598 fi
24599 fi
24600
24601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24602 $as_echo_n "checking for Boot JDK... " >&6; }
24603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24604 $as_echo "$BOOT_JDK" >&6; }
24605 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24606 $as_echo_n "checking Boot JDK version... " >&6; }
24607 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24608 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24609 $as_echo "$BOOT_JDK_VERSION" >&6; }
24610 fi # end check jdk version
24611 fi # end check javac
24612 fi # end check java
24613 fi # end check boot jdk found
24614 fi
24615
24616 done
24617 fi
24618
24619
24620 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24621 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24622 # Do we have a bin/java?
24623 if test ! -x "$BOOT_JDK/bin/java"; then
24624 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24625 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24626 BOOT_JDK_FOUND=no
24627 else
24628 # Do we have a bin/javac?
24629 if test ! -x "$BOOT_JDK/bin/javac"; then
24630 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24631 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24632 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24633 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24634 BOOT_JDK_FOUND=no
24635 else
24636 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24637 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24638
24639 # Extra M4 quote needed to protect [] in grep expression.
24640 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24641 if test "x$FOUND_CORRECT_VERSION" = x; then
24642 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24643 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24644 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24645 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24646 BOOT_JDK_FOUND=no
24647 else
24648 # We're done! :-)
24649 BOOT_JDK_FOUND=yes
24650
24651 # Only process if variable expands to non-empty
24652
24653 if test "x$BOOT_JDK" != x; then
24654 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24655
24656 # Input might be given as Windows format, start by converting to
24657 # unix format.
24658 path="$BOOT_JDK"
24659 new_path=`$CYGPATH -u "$path"`
24660
24661 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24662 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24663 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24664 # "foo.exe" is OK but "foo" is an error.
24665 #
24666 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24667 # It is also a way to make sure we got the proper file name for the real test later on.
24668 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24669 if test "x$test_shortpath" = x; then
24670 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24671 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24672 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24673 fi
24674
24675 # Call helper function which possibly converts this using DOS-style short mode.
24676 # If so, the updated path is stored in $new_path.
24677
24678 input_path="$new_path"
24679 # Check if we need to convert this using DOS-style short mode. If the path
24680 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24681 # take no chances and rewrite it.
24682 # Note: m4 eats our [], so we need to use [ and ] instead.
24683 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24684 if test "x$has_forbidden_chars" != x; then
24685 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24686 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24687 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24688 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24689 # Going to short mode and back again did indeed matter. Since short mode is
24690 # case insensitive, let's make it lowercase to improve readability.
24691 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24692 # Now convert it back to Unix-stile (cygpath)
24693 input_path=`$CYGPATH -u "$shortmode_path"`
24694 new_path="$input_path"
24695 fi
24696 fi
24697
24698 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24699 if test "x$test_cygdrive_prefix" = x; then
24700 # As a simple fix, exclude /usr/bin since it's not a real path.
24701 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24702 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24703 # a path prefixed by /cygdrive for fixpath to work.
24704 new_path="$CYGWIN_ROOT_PATH$input_path"
24705 fi
24706 fi
24707
24708
24709 if test "x$path" != "x$new_path"; then
24710 BOOT_JDK="$new_path"
24711 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24712 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24713 fi
24714
24715 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24716
24717 path="$BOOT_JDK"
24718 has_colon=`$ECHO $path | $GREP ^.:`
24719 new_path="$path"
24720 if test "x$has_colon" = x; then
24721 # Not in mixed or Windows style, start by that.
24722 new_path=`cmd //c echo $path`
24723 fi
24724
24725
24726 input_path="$new_path"
24727 # Check if we need to convert this using DOS-style short mode. If the path
24728 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24729 # take no chances and rewrite it.
24730 # Note: m4 eats our [], so we need to use [ and ] instead.
24731 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24732 if test "x$has_forbidden_chars" != x; then
24733 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24734 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24735 fi
24736
24737
24738 windows_path="$new_path"
24739 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24740 unix_path=`$CYGPATH -u "$windows_path"`
24741 new_path="$unix_path"
24742 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24743 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24744 new_path="$unix_path"
24745 fi
24746
24747 if test "x$path" != "x$new_path"; then
24748 BOOT_JDK="$new_path"
24749 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24750 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24751 fi
24752
24753 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24754 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24755
24756 else
24757 # We're on a unix platform. Hooray! :)
24758 path="$BOOT_JDK"
24759 has_space=`$ECHO "$path" | $GREP " "`
24760 if test "x$has_space" != x; then
24761 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24762 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24763 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24764 fi
24765
24766 # Use eval to expand a potential ~
24767 eval path="$path"
24768 if test ! -f "$path" && test ! -d "$path"; then
24769 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24770 fi
24771
24772 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24773 fi
24774 fi
24775
24776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24777 $as_echo_n "checking for Boot JDK... " >&6; }
24778 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24779 $as_echo "$BOOT_JDK" >&6; }
24780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24781 $as_echo_n "checking Boot JDK version... " >&6; }
24782 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24783 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24784 $as_echo "$BOOT_JDK_VERSION" >&6; }
24785 fi # end check jdk version
24786 fi # end check javac
24787 fi # end check java
24788 fi # end check boot jdk found
24789 fi
24790
24791 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24792
24793 if test "x$BOOT_JDK_FOUND" = xno; then
24794 # Now execute the test
24795
24796 BOOT_JDK_PREFIX="/usr/lib/jvm"
24797 BOOT_JDK_SUFFIX=""
24798 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24799 if test "x$ALL_JDKS_FOUND" != x; then
24800 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24801
24802 if test "x$BOOT_JDK_FOUND" = xno; then
24803 # Now execute the test
24804
24805 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24806 if test -d "$BOOT_JDK"; then
24807 BOOT_JDK_FOUND=maybe
24808 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24809 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24810 fi
24811
24812
24813 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24814 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24815 # Do we have a bin/java?
24816 if test ! -x "$BOOT_JDK/bin/java"; then
24817 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24818 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24819 BOOT_JDK_FOUND=no
24820 else
24821 # Do we have a bin/javac?
24822 if test ! -x "$BOOT_JDK/bin/javac"; then
24823 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24824 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24825 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24826 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24827 BOOT_JDK_FOUND=no
24828 else
24829 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24830 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24831
24832 # Extra M4 quote needed to protect [] in grep expression.
24833 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24834 if test "x$FOUND_CORRECT_VERSION" = x; then
24835 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24836 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24837 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24838 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24839 BOOT_JDK_FOUND=no
24840 else
24841 # We're done! :-)
24842 BOOT_JDK_FOUND=yes
24843
24844 # Only process if variable expands to non-empty
24845
24846 if test "x$BOOT_JDK" != x; then
24847 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24848
24849 # Input might be given as Windows format, start by converting to
24850 # unix format.
24851 path="$BOOT_JDK"
24852 new_path=`$CYGPATH -u "$path"`
24853
24854 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24855 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24856 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24857 # "foo.exe" is OK but "foo" is an error.
24858 #
24859 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24860 # It is also a way to make sure we got the proper file name for the real test later on.
24861 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24862 if test "x$test_shortpath" = x; then
24863 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24864 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24865 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24866 fi
24867
24868 # Call helper function which possibly converts this using DOS-style short mode.
24869 # If so, the updated path is stored in $new_path.
24870
24871 input_path="$new_path"
24872 # Check if we need to convert this using DOS-style short mode. If the path
24873 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24874 # take no chances and rewrite it.
24875 # Note: m4 eats our [], so we need to use [ and ] instead.
24876 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24877 if test "x$has_forbidden_chars" != x; then
24878 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24879 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24880 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24881 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24882 # Going to short mode and back again did indeed matter. Since short mode is
24883 # case insensitive, let's make it lowercase to improve readability.
24884 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24885 # Now convert it back to Unix-stile (cygpath)
24886 input_path=`$CYGPATH -u "$shortmode_path"`
24887 new_path="$input_path"