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 ENABLE_SJAVAC
636 SJAVAC_SERVER_JAVA_FLAGS
637 SJAVAC_SERVER_JAVA
638 JAVA_TOOL_FLAGS_SMALL
639 JAVA_FLAGS_SMALL
640 JAVA_FLAGS_BIG
641 JAVA_FLAGS
642 JOBS
643 MEMORY_SIZE
644 NUM_CORES
645 ENABLE_INTREE_EC
646 SALIB_NAME
647 HOTSPOT_MAKE_ARGS
648 MSVCP_DLL
649 MSVCR_DLL
650 LIBCXX
651 LLVM_LIBS
652 LLVM_LDFLAGS
653 LLVM_CFLAGS
654 LLVM_CONFIG
655 LIBFFI_LIBS
656 LIBFFI_CFLAGS
657 STATIC_CXX_SETTING
658 LIBDL
659 LIBM
660 LIBZIP_CAN_USE_MMAP
661 USE_EXTERNAL_LIBZ
662 USE_EXTERNAL_LIBPNG
663 PNG_LIBS
664 PNG_CFLAGS
665 USE_EXTERNAL_LCMS
666 LCMS_LIBS
667 LCMS_CFLAGS
668 USE_EXTERNAL_LIBGIF
669 USE_EXTERNAL_LIBJPEG
670 ALSA_LIBS
671 ALSA_CFLAGS
672 FREETYPE_BUNDLE_LIB_PATH
673 FREETYPE_LIBS
674 FREETYPE_CFLAGS
675 CUPS_CFLAGS
676 X_EXTRA_LIBS
677 X_LIBS
678 X_PRE_LIBS
679 X_CFLAGS
680 XMKMF
681 FIXPATH
682 GCOV_ENABLED
683 ZIP_DEBUGINFO_FILES
684 ENABLE_DEBUG_SYMBOLS
685 CFLAGS_WARNINGS_ARE_ERRORS
686 DISABLE_WARNING_PREFIX
687 WARNINGS_AS_ERRORS
688 COMPILER_SUPPORTS_TARGET_BITS_FLAG
689 ZERO_ARCHFLAG
690 LDFLAGS_TESTEXE_SUFFIX
691 LDFLAGS_TESTLIB_SUFFIX
692 LDFLAGS_TESTEXE
693 LDFLAGS_TESTLIB
694 LDFLAGS_CXX_JDK
695 LDFLAGS_JDKEXE_SUFFIX
696 LDFLAGS_JDKLIB_SUFFIX
697 LDFLAGS_JDKEXE
698 LDFLAGS_JDKLIB
699 CXXFLAGS_TESTEXE
700 CXXFLAGS_TESTLIB
701 CFLAGS_TESTEXE
702 CFLAGS_TESTLIB
703 CXXFLAGS_JDKEXE
704 CXXFLAGS_JDKLIB
705 CFLAGS_JDKEXE
706 CFLAGS_JDKLIB
707 MACOSX_VERSION_MIN
708 LEGACY_EXTRA_LDFLAGS
709 LEGACY_EXTRA_CXXFLAGS
710 LEGACY_EXTRA_CFLAGS
711 CXX_O_FLAG_NONE
712 CXX_O_FLAG_DEBUG
713 CXX_O_FLAG_NORM
714 CXX_O_FLAG_HI
715 CXX_O_FLAG_HIGHEST
716 C_O_FLAG_NONE
717 C_O_FLAG_DEBUG
718 C_O_FLAG_NORM
719 C_O_FLAG_HI
720 C_O_FLAG_HIGHEST
721 CXXFLAGS_DEBUG_OPTIONS
722 CFLAGS_DEBUG_OPTIONS
723 CXXFLAGS_DEBUG_SYMBOLS
724 CFLAGS_DEBUG_SYMBOLS
725 CXX_FLAG_DEPS
726 C_FLAG_DEPS
727 SET_SHARED_LIBRARY_MAPFILE
728 SET_SHARED_LIBRARY_NAME
729 SET_SHARED_LIBRARY_ORIGIN
730 SET_EXECUTABLE_ORIGIN
731 CXX_FLAG_REORDER
732 C_FLAG_REORDER
733 SYSROOT_LDFLAGS
734 SYSROOT_CFLAGS
735 RC_FLAGS
736 AR_OUT_OPTION
737 LD_OUT_OPTION
738 EXE_OUT_OPTION
739 CC_OUT_OPTION
740 POST_STRIP_CMD
741 ARFLAGS
742 COMPILER_TARGET_BITS_FLAG
743 JT_HOME
744 JTREGEXE
745 USING_BROKEN_SUSE_LD
746 PACKAGE_PATH
747 USE_CLANG
748 HOTSPOT_LD
749 HOTSPOT_CXX
750 HOTSPOT_RC
751 HOTSPOT_MT
752 BUILD_LD
753 BUILD_CXX
754 BUILD_CC
755 ac_ct_OBJDUMP
756 OBJDUMP
757 ac_ct_OBJCOPY
758 OBJCOPY
759 ac_ct_NM
760 ac_ct_STRIP
761 GNM
762 NM
763 STRIP
764 MSBUILD
765 DUMPBIN
766 RC
767 MT
768 LIPO
769 ac_ct_AR
770 AR
771 AS
772 LDCXX
773 LD
774 CXXCPP
775 CPP
776 ac_ct_CXX
777 CXXFLAGS
778 CXX
779 ac_ct_PROPER_COMPILER_CXX
780 PROPER_COMPILER_CXX
781 TOOLCHAIN_PATH_CXX
782 POTENTIAL_CXX
783 OBJEXT
784 EXEEXT
785 ac_ct_CC
786 CPPFLAGS
787 LDFLAGS
788 CFLAGS
789 CC
790 ac_ct_PROPER_COMPILER_CC
791 PROPER_COMPILER_CC
792 TOOLCHAIN_PATH_CC
793 POTENTIAL_CC
794 VS_LIB
795 VS_INCLUDE
796 VS_PATH
797 CYGWIN_LINK
798 EXE_SUFFIX
799 OBJ_SUFFIX
800 STATIC_LIBRARY
801 SHARED_LIBRARY
802 STATIC_LIBRARY_SUFFIX
803 SHARED_LIBRARY_SUFFIX
804 LIBRARY_PREFIX
805 TOOLCHAIN_TYPE
806 BUILD_HOTSPOT
807 HOTSPOT_DIST
808 BUILD_OUTPUT
809 OVERRIDE_SRC_ROOT
810 ADD_SRC_ROOT
811 JDK_TOPDIR
812 NASHORN_TOPDIR
813 HOTSPOT_TOPDIR
814 JAXWS_TOPDIR
815 JAXP_TOPDIR
816 CORBA_TOPDIR
817 LANGTOOLS_TOPDIR
818 JAVAC_FLAGS
819 BOOT_JDK_SOURCETARGET
820 JARSIGNER
821 JAR
822 JAVAH
823 JAVAC
824 JAVA
825 BOOT_JDK
826 JAVA_CHECK
827 JAVAC_CHECK
828 COOKED_BUILD_NUMBER
829 JDK_VERSION
830 COPYRIGHT_YEAR
831 MACOSX_BUNDLE_ID_BASE
832 MACOSX_BUNDLE_NAME_BASE
833 COMPANY_NAME
834 JDK_RC_PLATFORM_NAME
835 PRODUCT_SUFFIX
836 PRODUCT_NAME
837 LAUNCHER_NAME
838 MILESTONE
839 JDK_BUILD_NUMBER
840 JDK_UPDATE_VERSION
841 JDK_MICRO_VERSION
842 JDK_MINOR_VERSION
843 JDK_MAJOR_VERSION
844 USER_RELEASE_SUFFIX
845 COMPRESS_JARS
846 RMICONNECTOR_IIOP
847 UNLIMITED_CRYPTO
848 CACERTS_FILE
849 TEST_IN_BUILD
850 BUILD_HEADLESS
851 SUPPORT_HEADFUL
852 SUPPORT_HEADLESS
853 BDEPS_FTP
854 BDEPS_UNZIP
855 OS_VERSION_MICRO
856 OS_VERSION_MINOR
857 OS_VERSION_MAJOR
858 PKG_CONFIG
859 BASH_ARGS
860 CODESIGN
861 XATTR
862 DSYMUTIL
863 IS_GNU_TIME
864 TIME
865 STAT
866 HG
867 READELF
868 OTOOL
869 LDD
870 ZIP
871 UNZIP
872 FIND_DELETE
873 OUTPUT_SYNC
874 OUTPUT_SYNC_SUPPORTED
875 MAKE
876 CHECK_TOOLSDIR_MAKE
877 CHECK_TOOLSDIR_GMAKE
878 CHECK_MAKE
879 CHECK_GMAKE
880 PKGHANDLER
881 CONFIGURESUPPORT_OUTPUTDIR
882 OUTPUT_ROOT
883 CONF_NAME
884 SPEC
885 SDKROOT
886 XCODEBUILD
887 BUILD_VARIANT_RELEASE
888 DEBUG_CLASSFILES
889 FASTDEBUG
890 VARIANT
891 DEBUG_LEVEL
892 MACOSX_UNIVERSAL
893 INCLUDE_SA
894 JVM_VARIANT_CORE
895 JVM_VARIANT_ZEROSHARK
896 JVM_VARIANT_ZERO
897 JVM_VARIANT_KERNEL
898 JVM_VARIANT_MINIMAL1
899 JVM_VARIANT_CLIENT
900 JVM_VARIANT_SERVER
901 JVM_VARIANTS
902 JVM_INTERPRETER
903 JDK_VARIANT
904 SET_OPENJDK
905 CANONICAL_TOPDIR
906 ORIGINAL_TOPDIR
907 TOPDIR
908 PATH_SEP
909 ZERO_ARCHDEF
910 DEFINE_CROSS_COMPILE_ARCH
911 LP64
912 OPENJDK_TARGET_OS_EXPORT_DIR
913 OPENJDK_TARGET_CPU_JLI_CFLAGS
914 OPENJDK_TARGET_CPU_OSARCH
915 OPENJDK_TARGET_CPU_ISADIR
916 OPENJDK_TARGET_CPU_LIBDIR
917 OPENJDK_TARGET_CPU_LEGACY_LIB
918 OPENJDK_TARGET_CPU_LEGACY
919 REQUIRED_OS_VERSION
920 REQUIRED_OS_NAME
921 COMPILE_TYPE
922 OPENJDK_TARGET_CPU_ENDIAN
923 OPENJDK_TARGET_CPU_BITS
924 OPENJDK_TARGET_CPU_ARCH
925 OPENJDK_TARGET_CPU
926 OPENJDK_TARGET_OS_ENV
927 OPENJDK_TARGET_OS_TYPE
928 OPENJDK_TARGET_OS
929 OPENJDK_BUILD_CPU_ENDIAN
930 OPENJDK_BUILD_CPU_BITS
931 OPENJDK_BUILD_CPU_ARCH
932 OPENJDK_BUILD_CPU
933 OPENJDK_BUILD_OS_ENV
934 OPENJDK_BUILD_OS_TYPE
935 OPENJDK_BUILD_OS
936 OPENJDK_BUILD_AUTOCONF_NAME
937 OPENJDK_TARGET_AUTOCONF_NAME
938 target_os
939 target_vendor
940 target_cpu
941 target
942 host_os
943 host_vendor
944 host_cpu
945 host
946 build_os
947 build_vendor
948 build_cpu
949 build
950 CPIO
951 SETFILE
952 DF
953 READLINK
954 CYGPATH
955 SED
956 FGREP
957 EGREP
958 GREP
959 AWK
960 XARGS
961 WHICH
962 WC
963 UNIQ
964 UNAME
965 TR
966 TOUCH
967 TEE
968 TAR
969 TAIL
970 SORT
971 SH
972 RM
973 PRINTF
974 NAWK
975 MV
976 MKTEMP
977 MKDIR
978 LS
979 LN
980 HEAD
981 FIND
982 FILE
983 EXPR
984 ECHO
985 DIRNAME
986 DIFF
987 DATE
988 CUT
989 CP
990 COMM
991 CMP
992 CHMOD
993 CAT
994 BASH
995 BASENAME
996 DATE_WHEN_CONFIGURED
997 ORIGINAL_PATH
998 CONFIGURE_COMMAND_LINE
999 target_alias
1000 host_alias
1001 build_alias
1002 LIBS
1003 ECHO_T
1004 ECHO_N
1005 ECHO_C
1006 DEFS
1007 mandir
1008 localedir
1009 libdir
1010 psdir
1011 pdfdir
1012 dvidir
1013 htmldir
1014 infodir
1015 docdir
1016 oldincludedir
1017 includedir
1018 localstatedir
1019 sharedstatedir
1020 sysconfdir
1021 datadir
1022 datarootdir
1023 libexecdir
1024 sbindir
1025 bindir
1026 program_transform_name
1027 prefix
1028 exec_prefix
1029 PACKAGE_URL
1030 PACKAGE_BUGREPORT
1031 PACKAGE_STRING
1032 PACKAGE_VERSION
1033 PACKAGE_TARNAME
1034 PACKAGE_NAME
1035 PATH_SEPARATOR
1036 SHELL'
1037 ac_subst_files=''
1038 ac_user_opts='
1039 enable_option_checking
1040 with_target_bits
1041 enable_openjdk_only
1042 with_custom_make_dir
1043 with_jdk_variant
1044 with_jvm_interpreter
1045 with_jvm_variants
1046 enable_debug
1047 with_debug_level
1048 with_devkit
1049 with_sys_root
1050 with_sysroot
1051 with_tools_dir
1052 with_toolchain_path
1053 with_extra_path
1054 with_sdk_name
1055 with_conf_name
1056 with_output_sync
1057 with_builddeps_conf
1058 with_builddeps_server
1059 with_builddeps_dir
1060 with_builddeps_group
1061 enable_headful
1062 enable_hotspot_test_in_build
1063 with_cacerts_file
1064 enable_unlimited_crypto
1065 enable_rmiconnector_iiop
1066 with_milestone
1067 with_update_version
1068 with_user_release_suffix
1069 with_build_number
1070 with_copyright_year
1071 with_boot_jdk
1072 with_add_source_root
1073 with_override_source_root
1074 with_adds_and_overrides
1075 with_override_langtools
1076 with_override_corba
1077 with_override_jaxp
1078 with_override_jaxws
1079 with_override_hotspot
1080 with_override_nashorn
1081 with_override_jdk
1082 with_import_hotspot
1083 with_toolchain_type
1084 with_toolchain_version
1085 with_jtreg
1086 with_extra_cflags
1087 with_extra_cxxflags
1088 with_extra_ldflags
1089 enable_warnings_as_errors
1090 enable_debug_symbols
1091 enable_zip_debug_info
1092 enable_native_coverage
1093 with_x
1094 with_cups
1095 with_cups_include
1096 with_freetype
1097 with_freetype_include
1098 with_freetype_lib
1099 with_freetype_src
1100 enable_freetype_bundling
1101 with_alsa
1102 with_alsa_include
1103 with_alsa_lib
1104 with_libjpeg
1105 with_giflib
1106 with_lcms
1107 with_libpng
1108 with_zlib
1109 with_stdc__lib
1110 with_msvcr_dll
1111 with_msvcp_dll
1112 with_dxsdk
1113 with_dxsdk_lib
1114 with_dxsdk_include
1115 with_num_cores
1116 with_memory_size
1117 with_jobs
1118 with_boot_jdk_jvmargs
1119 with_sjavac_server_java
1120 enable_sjavac
1121 enable_precompiled_headers
1122 enable_ccache
1123 with_ccache_dir
1124 '
1125 ac_precious_vars='build_alias
1126 host_alias
1127 target_alias
1128 BASENAME
1129 BASH
1130 CAT
1131 CHMOD
1132 CMP
1133 COMM
1134 CP
1135 CUT
1136 DATE
1137 DIFF
1138 DIRNAME
1139 ECHO
1140 EXPR
1141 FILE
1142 FIND
1143 HEAD
1144 LN
1145 LS
1146 MKDIR
1147 MKTEMP
1148 MV
1149 NAWK
1150 PRINTF
1151 RM
1152 SH
1153 SORT
1154 TAIL
1155 TAR
1156 TEE
1157 TOUCH
1158 TR
1159 UNAME
1160 UNIQ
1161 WC
1162 WHICH
1163 XARGS
1164 AWK
1165 GREP
1166 EGREP
1167 FGREP
1168 SED
1169 CYGPATH
1170 READLINK
1171 DF
1172 SETFILE
1173 CPIO
1174 UNZIP
1175 ZIP
1176 LDD
1177 OTOOL
1178 READELF
1179 HG
1180 STAT
1181 TIME
1182 DSYMUTIL
1183 XATTR
1184 CODESIGN
1185 PKG_CONFIG
1186 JAVA
1187 JAVAC
1188 JAVAH
1189 JAR
1190 JARSIGNER
1191 CC
1192 CFLAGS
1193 LDFLAGS
1194 LIBS
1195 CPPFLAGS
1196 CXX
1197 CXXFLAGS
1198 CCC
1199 CPP
1200 CXXCPP
1201 AS
1202 AR
1203 LIPO
1204 STRIP
1205 NM
1206 GNM
1207 OBJCOPY
1208 OBJDUMP
1209 BUILD_CC
1210 BUILD_CXX
1211 BUILD_LD
1212 JTREGEXE
1213 XMKMF
1214 FREETYPE_CFLAGS
1215 FREETYPE_LIBS
1216 ALSA_CFLAGS
1217 ALSA_LIBS
1218 LCMS_CFLAGS
1219 LCMS_LIBS
1220 PNG_CFLAGS
1221 PNG_LIBS
1222 LIBFFI_CFLAGS
1223 LIBFFI_LIBS
1224 CCACHE'
1225
1226
1227 # Initialize some variables set by options.
1228 ac_init_help=
1229 ac_init_version=false
1230 ac_unrecognized_opts=
1231 ac_unrecognized_sep=
1232 # The variables have the same names as the options, with
1233 # dashes changed to underlines.
1234 cache_file=/dev/null
1235 exec_prefix=NONE
1236 no_create=
1237 no_recursion=
1238 prefix=NONE
1239 program_prefix=NONE
1240 program_suffix=NONE
1241 program_transform_name=s,x,x,
1242 silent=
1243 site=
1244 srcdir=
1245 verbose=
1246 x_includes=NONE
1247 x_libraries=NONE
1248
1249 # Installation directory options.
1250 # These are left unexpanded so users can "make install exec_prefix=/foo"
1251 # and all the variables that are supposed to be based on exec_prefix
1252 # by default will actually change.
1253 # Use braces instead of parens because sh, perl, etc. also accept them.
1254 # (The list follows the same order as the GNU Coding Standards.)
1255 bindir='${exec_prefix}/bin'
1256 sbindir='${exec_prefix}/sbin'
1257 libexecdir='${exec_prefix}/libexec'
1258 datarootdir='${prefix}/share'
1259 datadir='${datarootdir}'
1260 sysconfdir='${prefix}/etc'
1261 sharedstatedir='${prefix}/com'
1262 localstatedir='${prefix}/var'
1263 includedir='${prefix}/include'
1264 oldincludedir='/usr/include'
1265 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1266 infodir='${datarootdir}/info'
1267 htmldir='${docdir}'
1268 dvidir='${docdir}'
1269 pdfdir='${docdir}'
1270 psdir='${docdir}'
1271 libdir='${exec_prefix}/lib'
1272 localedir='${datarootdir}/locale'
1273 mandir='${datarootdir}/man'
1274
1275 ac_prev=
1276 ac_dashdash=
1277 for ac_option
1278 do
1279 # If the previous option needs an argument, assign it.
1280 if test -n "$ac_prev"; then
1281 eval $ac_prev=\$ac_option
1282 ac_prev=
1283 continue
1284 fi
1285
1286 case $ac_option in
1287 *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1288 *=) ac_optarg= ;;
1289 *) ac_optarg=yes ;;
1290 esac
1291
1292 # Accept the important Cygnus configure options, so we can diagnose typos.
1293
1294 case $ac_dashdash$ac_option in
1295 --)
1296 ac_dashdash=yes ;;
1297
1298 -bindir | --bindir | --bindi | --bind | --bin | --bi)
1299 ac_prev=bindir ;;
1300 -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1301 bindir=$ac_optarg ;;
1302
1303 -build | --build | --buil | --bui | --bu)
1304 ac_prev=build_alias ;;
1305 -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1306 build_alias=$ac_optarg ;;
1307
1308 -cache-file | --cache-file | --cache-fil | --cache-fi \
1309 | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1310 ac_prev=cache_file ;;
1311 -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1312 | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1313 cache_file=$ac_optarg ;;
1314
1315 --config-cache | -C)
1316 cache_file=config.cache ;;
1317
1318 -datadir | --datadir | --datadi | --datad)
1319 ac_prev=datadir ;;
1320 -datadir=* | --datadir=* | --datadi=* | --datad=*)
1321 datadir=$ac_optarg ;;
1322
1323 -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1324 | --dataroo | --dataro | --datar)
1325 ac_prev=datarootdir ;;
1326 -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1327 | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1328 datarootdir=$ac_optarg ;;
1329
1330 -disable-* | --disable-*)
1331 ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1332 # Reject names that are not valid shell variable names.
1333 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1334 as_fn_error $? "invalid feature name: $ac_useropt"
1335 ac_useropt_orig=$ac_useropt
1336 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1337 case $ac_user_opts in
1338 *"
1339 "enable_$ac_useropt"
1340 "*) ;;
1341 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1342 ac_unrecognized_sep=', ';;
1343 esac
1344 eval enable_$ac_useropt=no ;;
1345
1346 -docdir | --docdir | --docdi | --doc | --do)
1347 ac_prev=docdir ;;
1348 -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1349 docdir=$ac_optarg ;;
1350
1351 -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1352 ac_prev=dvidir ;;
1353 -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1354 dvidir=$ac_optarg ;;
1355
1356 -enable-* | --enable-*)
1357 ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1358 # Reject names that are not valid shell variable names.
1359 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1360 as_fn_error $? "invalid feature name: $ac_useropt"
1361 ac_useropt_orig=$ac_useropt
1362 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1363 case $ac_user_opts in
1364 *"
1365 "enable_$ac_useropt"
1366 "*) ;;
1367 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1368 ac_unrecognized_sep=', ';;
1369 esac
1370 eval enable_$ac_useropt=\$ac_optarg ;;
1371
1372 -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1373 | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1374 | --exec | --exe | --ex)
1375 ac_prev=exec_prefix ;;
1376 -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1377 | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1378 | --exec=* | --exe=* | --ex=*)
1379 exec_prefix=$ac_optarg ;;
1380
1381 -gas | --gas | --ga | --g)
1382 # Obsolete; use --with-gas.
1383 with_gas=yes ;;
1384
1385 -help | --help | --hel | --he | -h)
1386 ac_init_help=long ;;
1387 -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1388 ac_init_help=recursive ;;
1389 -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1390 ac_init_help=short ;;
1391
1392 -host | --host | --hos | --ho)
1393 ac_prev=host_alias ;;
1394 -host=* | --host=* | --hos=* | --ho=*)
1395 host_alias=$ac_optarg ;;
1396
1397 -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1398 ac_prev=htmldir ;;
1399 -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1400 | --ht=*)
1401 htmldir=$ac_optarg ;;
1402
1403 -includedir | --includedir | --includedi | --included | --include \
1404 | --includ | --inclu | --incl | --inc)
1405 ac_prev=includedir ;;
1406 -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1407 | --includ=* | --inclu=* | --incl=* | --inc=*)
1408 includedir=$ac_optarg ;;
1409
1410 -infodir | --infodir | --infodi | --infod | --info | --inf)
1411 ac_prev=infodir ;;
1412 -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1413 infodir=$ac_optarg ;;
1414
1415 -libdir | --libdir | --libdi | --libd)
1416 ac_prev=libdir ;;
1417 -libdir=* | --libdir=* | --libdi=* | --libd=*)
1418 libdir=$ac_optarg ;;
1419
1420 -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1421 | --libexe | --libex | --libe)
1422 ac_prev=libexecdir ;;
1423 -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1424 | --libexe=* | --libex=* | --libe=*)
1425 libexecdir=$ac_optarg ;;
1426
1427 -localedir | --localedir | --localedi | --localed | --locale)
1428 ac_prev=localedir ;;
1429 -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1430 localedir=$ac_optarg ;;
1431
1432 -localstatedir | --localstatedir | --localstatedi | --localstated \
1433 | --localstate | --localstat | --localsta | --localst | --locals)
1434 ac_prev=localstatedir ;;
1435 -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1436 | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1437 localstatedir=$ac_optarg ;;
1438
1439 -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1440 ac_prev=mandir ;;
1441 -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1442 mandir=$ac_optarg ;;
1443
1444 -nfp | --nfp | --nf)
1445 # Obsolete; use --without-fp.
1446 with_fp=no ;;
1447
1448 -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1449 | --no-cr | --no-c | -n)
1450 no_create=yes ;;
1451
1452 -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1453 | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1454 no_recursion=yes ;;
1455
1456 -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1457 | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1458 | --oldin | --oldi | --old | --ol | --o)
1459 ac_prev=oldincludedir ;;
1460 -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1461 | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1462 | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1463 oldincludedir=$ac_optarg ;;
1464
1465 -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1466 ac_prev=prefix ;;
1467 -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1468 prefix=$ac_optarg ;;
1469
1470 -program-prefix | --program-prefix | --program-prefi | --program-pref \
1471 | --program-pre | --program-pr | --program-p)
1472 ac_prev=program_prefix ;;
1473 -program-prefix=* | --program-prefix=* | --program-prefi=* \
1474 | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1475 program_prefix=$ac_optarg ;;
1476
1477 -program-suffix | --program-suffix | --program-suffi | --program-suff \
1478 | --program-suf | --program-su | --program-s)
1479 ac_prev=program_suffix ;;
1480 -program-suffix=* | --program-suffix=* | --program-suffi=* \
1481 | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1482 program_suffix=$ac_optarg ;;
1483
1484 -program-transform-name | --program-transform-name \
1485 | --program-transform-nam | --program-transform-na \
1486 | --program-transform-n | --program-transform- \
1487 | --program-transform | --program-transfor \
1488 | --program-transfo | --program-transf \
1489 | --program-trans | --program-tran \
1490 | --progr-tra | --program-tr | --program-t)
1491 ac_prev=program_transform_name ;;
1492 -program-transform-name=* | --program-transform-name=* \
1493 | --program-transform-nam=* | --program-transform-na=* \
1494 | --program-transform-n=* | --program-transform-=* \
1495 | --program-transform=* | --program-transfor=* \
1496 | --program-transfo=* | --program-transf=* \
1497 | --program-trans=* | --program-tran=* \
1498 | --progr-tra=* | --program-tr=* | --program-t=*)
1499 program_transform_name=$ac_optarg ;;
1500
1501 -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1502 ac_prev=pdfdir ;;
1503 -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1504 pdfdir=$ac_optarg ;;
1505
1506 -psdir | --psdir | --psdi | --psd | --ps)
1507 ac_prev=psdir ;;
1508 -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1509 psdir=$ac_optarg ;;
1510
1511 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1512 | -silent | --silent | --silen | --sile | --sil)
1513 silent=yes ;;
1514
1515 -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1516 ac_prev=sbindir ;;
1517 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1518 | --sbi=* | --sb=*)
1519 sbindir=$ac_optarg ;;
1520
1521 -sharedstatedir | --sharedstatedir | --sharedstatedi \
1522 | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1523 | --sharedst | --shareds | --shared | --share | --shar \
1524 | --sha | --sh)
1525 ac_prev=sharedstatedir ;;
1526 -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1527 | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1528 | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1529 | --sha=* | --sh=*)
1530 sharedstatedir=$ac_optarg ;;
1531
1532 -site | --site | --sit)
1533 ac_prev=site ;;
1534 -site=* | --site=* | --sit=*)
1535 site=$ac_optarg ;;
1536
1537 -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1538 ac_prev=srcdir ;;
1539 -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1540 srcdir=$ac_optarg ;;
1541
1542 -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1543 | --syscon | --sysco | --sysc | --sys | --sy)
1544 ac_prev=sysconfdir ;;
1545 -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1546 | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1547 sysconfdir=$ac_optarg ;;
1548
1549 -target | --target | --targe | --targ | --tar | --ta | --t)
1550 ac_prev=target_alias ;;
1551 -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1552 target_alias=$ac_optarg ;;
1553
1554 -v | -verbose | --verbose | --verbos | --verbo | --verb)
1555 verbose=yes ;;
1556
1557 -version | --version | --versio | --versi | --vers | -V)
1558 ac_init_version=: ;;
1559
1560 -with-* | --with-*)
1561 ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1562 # Reject names that are not valid shell variable names.
1563 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1564 as_fn_error $? "invalid package name: $ac_useropt"
1565 ac_useropt_orig=$ac_useropt
1566 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1567 case $ac_user_opts in
1568 *"
1569 "with_$ac_useropt"
1570 "*) ;;
1571 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1572 ac_unrecognized_sep=', ';;
1573 esac
1574 eval with_$ac_useropt=\$ac_optarg ;;
1575
1576 -without-* | --without-*)
1577 ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1578 # Reject names that are not valid shell variable names.
1579 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1580 as_fn_error $? "invalid package name: $ac_useropt"
1581 ac_useropt_orig=$ac_useropt
1582 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1583 case $ac_user_opts in
1584 *"
1585 "with_$ac_useropt"
1586 "*) ;;
1587 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1588 ac_unrecognized_sep=', ';;
1589 esac
1590 eval with_$ac_useropt=no ;;
1591
1592 --x)
1593 # Obsolete; use --with-x.
1594 with_x=yes ;;
1595
1596 -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1597 | --x-incl | --x-inc | --x-in | --x-i)
1598 ac_prev=x_includes ;;
1599 -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1600 | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1601 x_includes=$ac_optarg ;;
1602
1603 -x-libraries | --x-libraries | --x-librarie | --x-librari \
1604 | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1605 ac_prev=x_libraries ;;
1606 -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1607 | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1608 x_libraries=$ac_optarg ;;
1609
1610 -*) as_fn_error $? "unrecognized option: \`$ac_option'
1611 Try \`$0 --help' for more information"
1612 ;;
1613
1614 *=*)
1615 ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1616 # Reject names that are not valid shell variable names.
1617 case $ac_envvar in #(
1618 '' | [0-9]* | *[!_$as_cr_alnum]* )
1619 as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1620 esac
1621 eval $ac_envvar=\$ac_optarg
1622 export $ac_envvar ;;
1623
1624 *)
1625 # FIXME: should be removed in autoconf 3.0.
1626 $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1627 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1628 $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1629 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1630 ;;
1631
1632 esac
1633 done
1634
1635 if test -n "$ac_prev"; then
1636 ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1637 as_fn_error $? "missing argument to $ac_option"
1638 fi
1639
1640 if test -n "$ac_unrecognized_opts"; then
1641 case $enable_option_checking in
1642 no) ;;
1643 fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1644 *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1645 esac
1646 fi
1647
1648 # Check all directory arguments for consistency.
1649 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
1650 datadir sysconfdir sharedstatedir localstatedir includedir \
1651 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1652 libdir localedir mandir
1653 do
1654 eval ac_val=\$$ac_var
1655 # Remove trailing slashes.
1656 case $ac_val in
1657 */ )
1658 ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1659 eval $ac_var=\$ac_val;;
1660 esac
1661 # Be sure to have absolute directory names.
1662 case $ac_val in
1663 [\\/$]* | ?:[\\/]* ) continue;;
1664 NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1665 esac
1666 as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1667 done
1668
1669 # There might be people who depend on the old broken behavior: `$host'
1670 # used to hold the argument of --host etc.
1671 # FIXME: To remove some day.
1672 build=$build_alias
1673 host=$host_alias
1674 target=$target_alias
1675
1676 # FIXME: To remove some day.
1677 if test "x$host_alias" != x; then
1678 if test "x$build_alias" = x; then
1679 cross_compiling=maybe
1680 elif test "x$build_alias" != "x$host_alias"; then
1681 cross_compiling=yes
1682 fi
1683 fi
1684
1685 ac_tool_prefix=
1686 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1687
1688 test "$silent" = yes && exec 6>/dev/null
1689
1690
1691 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1692 ac_ls_di=`ls -di .` &&
1693 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1694 as_fn_error $? "working directory cannot be determined"
1695 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1696 as_fn_error $? "pwd does not report name of working directory"
1697
1698
1699 # Find the source files, if location was not specified.
1700 if test -z "$srcdir"; then
1701 ac_srcdir_defaulted=yes
1702 # Try the directory containing this script, then the parent directory.
1703 ac_confdir=`$as_dirname -- "$as_myself" ||
1704 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1705 X"$as_myself" : 'X\(//\)[^/]' \| \
1706 X"$as_myself" : 'X\(//\)$' \| \
1707 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1708 $as_echo X"$as_myself" |
1709 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1710 s//\1/
1711 q
1712 }
1713 /^X\(\/\/\)[^/].*/{
1714 s//\1/
1715 q
1716 }
1717 /^X\(\/\/\)$/{
1718 s//\1/
1719 q
1720 }
1721 /^X\(\/\).*/{
1722 s//\1/
1723 q
1724 }
1725 s/.*/./; q'`
1726 srcdir=$ac_confdir
1727 if test ! -r "$srcdir/$ac_unique_file"; then
1728 srcdir=..
1729 fi
1730 else
1731 ac_srcdir_defaulted=no
1732 fi
1733 if test ! -r "$srcdir/$ac_unique_file"; then
1734 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1735 as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1736 fi
1737 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1738 ac_abs_confdir=`(
1739 cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1740 pwd)`
1741 # When building in place, set srcdir=.
1742 if test "$ac_abs_confdir" = "$ac_pwd"; then
1743 srcdir=.
1744 fi
1745 # Remove unnecessary trailing slashes from srcdir.
1746 # Double slashes in file names in object file debugging info
1747 # mess up M-x gdb in Emacs.
1748 case $srcdir in
1749 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1750 esac
1751 for ac_var in $ac_precious_vars; do
1752 eval ac_env_${ac_var}_set=\${${ac_var}+set}
1753 eval ac_env_${ac_var}_value=\$${ac_var}
1754 eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1755 eval ac_cv_env_${ac_var}_value=\$${ac_var}
1756 done
1757
1758 #
1759 # Report the --help message.
1760 #
1761 if test "$ac_init_help" = "long"; then
1762 # Omit some internal or obsolete options to make the list less imposing.
1763 # This message is too long to be a string in the A/UX 3.1 sh.
1764 cat <<_ACEOF
1765 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1766
1767 Usage: $0 [OPTION]... [VAR=VALUE]...
1768
1769 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1770 VAR=VALUE. See below for descriptions of some of the useful variables.
1771
1772 Defaults for the options are specified in brackets.
1773
1774 Configuration:
1775 -h, --help display this help and exit
1776 --help=short display options specific to this package
1777 --help=recursive display the short help of all the included packages
1778 -V, --version display version information and exit
1779 -q, --quiet, --silent do not print \`checking ...' messages
1780 --cache-file=FILE cache test results in FILE [disabled]
1781 -C, --config-cache alias for \`--cache-file=config.cache'
1782 -n, --no-create do not create output files
1783 --srcdir=DIR find the sources in DIR [configure dir or \`..']
1784
1785 Installation directories:
1786 --prefix=PREFIX install architecture-independent files in PREFIX
1787 [$ac_default_prefix]
1788 --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
1789 [PREFIX]
1790
1791 By default, \`make install' will install all the files in
1792 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
1793 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1794 for instance \`--prefix=\$HOME'.
1795
1796 For better control, use the options below.
1797
1798 Fine tuning of the installation directories:
1799 --bindir=DIR user executables [EPREFIX/bin]
1800 --sbindir=DIR system admin executables [EPREFIX/sbin]
1801 --libexecdir=DIR program executables [EPREFIX/libexec]
1802 --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
1803 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
1804 --localstatedir=DIR modifiable single-machine data [PREFIX/var]
1805 --libdir=DIR object code libraries [EPREFIX/lib]
1806 --includedir=DIR C header files [PREFIX/include]
1807 --oldincludedir=DIR C header files for non-gcc [/usr/include]
1808 --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
1809 --datadir=DIR read-only architecture-independent data [DATAROOTDIR]
1810 --infodir=DIR info documentation [DATAROOTDIR/info]
1811 --localedir=DIR locale-dependent data [DATAROOTDIR/locale]
1812 --mandir=DIR man documentation [DATAROOTDIR/man]
1813 --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk]
1814 --htmldir=DIR html documentation [DOCDIR]
1815 --dvidir=DIR dvi documentation [DOCDIR]
1816 --pdfdir=DIR pdf documentation [DOCDIR]
1817 --psdir=DIR ps documentation [DOCDIR]
1818 _ACEOF
1819
1820 cat <<\_ACEOF
1821
1822 X features:
1823 --x-includes=DIR X include files are in DIR
1824 --x-libraries=DIR X library files are in DIR
1825
1826 System types:
1827 --build=BUILD configure for building on BUILD [guessed]
1828 --host=HOST cross-compile to build programs to run on HOST [BUILD]
1829 --target=TARGET configure for building compilers for TARGET [HOST]
1830 _ACEOF
1831 fi
1832
1833 if test -n "$ac_init_help"; then
1834 case $ac_init_help in
1835 short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1836 esac
1837 cat <<\_ACEOF
1838
1839 Optional Features:
1840 --disable-option-checking ignore unrecognized --enable/--with options
1841 --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
1842 --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
1843 --enable-openjdk-only suppress building custom source even if present
1844 [disabled]
1845 --enable-debug set the debug level to fastdebug (shorthand for
1846 --with-debug-level=fastdebug) [disabled]
1847 --disable-headful disable building headful support (graphical UI
1848 support) [enabled]
1849 --enable-hotspot-test-in-build
1850 run the Queens test after Hotspot build [disabled]
1851 --enable-unlimited-crypto
1852 Enable unlimited crypto policy [disabled]
1853 --enable-rmiconnector-iiop
1854 enable the JMX RMIConnector iiop transport
1855 [disabled]
1856 --disable-warnings-as-errors
1857 do not consider native warnings to be an error
1858 [enabled]
1859 --disable-debug-symbols disable generation of debug symbols [enabled]
1860 --disable-zip-debug-info
1861 disable zipping of debug-info files [enabled]
1862 --enable-native-coverage
1863 enable native compilation with code coverage
1864 data[disabled]
1865 --disable-freetype-bundling
1866 disable bundling of the freetype library with the
1867 build result [enabled on Windows or when using
1868 --with-freetype, disabled otherwise]
1869 --enable-sjavac use sjavac to do fast incremental compiles
1870 [disabled]
1871 --disable-precompiled-headers
1872 disable using precompiled headers when compiling C++
1873 [enabled]
1874 --enable-ccache enable using ccache to speed up recompilations
1875 [disabled]
1876
1877 Optional Packages:
1878 --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
1879 --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
1880 --with-target-bits build 32-bit or 64-bit binaries (for platforms that
1881 support it), e.g. --with-target-bits=32 [guessed]
1882 --with-custom-make-dir Deprecated. Option is kept for backwards
1883 compatibility and is ignored
1884 --with-jdk-variant JDK variant to build (normal) [normal]
1885 --with-jvm-interpreter JVM interpreter to build (template, cpp) [template]
1886 --with-jvm-variants JVM variants (separated by commas) to build (server,
1887 client, minimal1, kernel, zero, zeroshark, core)
1888 [server]
1889 --with-debug-level set the debug level (release, fastdebug, slowdebug,
1890 optimized (HotSpot build only)) [release]
1891 --with-devkit use this devkit for compilers, tools and resources
1892 --with-sys-root alias for --with-sysroot for backwards compatability
1893 --with-sysroot use this directory as sysroot
1894 --with-tools-dir alias for --with-toolchain-path for backwards
1895 compatibility
1896 --with-toolchain-path prepend these directories when searching for
1897 toolchain binaries (compilers etc)
1898 --with-extra-path prepend these directories to the default path
1899 --with-sdk-name use the platform SDK of the given name. [macosx]
1900 --with-conf-name use this as the name of the configuration [generated
1901 from important configuration options]
1902 --with-output-sync set make output sync type if supported by make.
1903 [recurse]
1904 --with-builddeps-conf use this configuration file for the builddeps
1905 --with-builddeps-server download and use build dependencies from this server
1906 url
1907 --with-builddeps-dir store downloaded build dependencies here
1908 [/localhome/builddeps]
1909 --with-builddeps-group chgrp the downloaded build dependencies to this
1910 group
1911 --with-cacerts-file specify alternative cacerts file
1912 --with-milestone Set milestone value for build [internal]
1913 --with-update-version Set update version value for build [b00]
1914 --with-user-release-suffix
1915 Add a custom string to the version string if build
1916 number is not set.[username_builddateb00]
1917 --with-build-number Set build number value for build [b00]
1918 --with-copyright-year Set copyright year value for build [current year]
1919 --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed]
1920 --with-add-source-root for each and every source directory, look in this
1921 additional source root for the same directory; if it
1922 exists and have files in it, include it in the build
1923 --with-override-source-root
1924 for each and every source directory, look in this
1925 override source root for the same directory; if it
1926 exists, use that directory instead and ignore the
1927 directory in the original source root
1928 --with-adds-and-overrides
1929 use the subdirs 'adds' and 'overrides' in the
1930 specified directory as add-source-root and
1931 override-source-root
1932 --with-override-langtools
1933 use this langtools dir for the build
1934 --with-override-corba use this corba dir for the build
1935 --with-override-jaxp use this jaxp dir for the build
1936 --with-override-jaxws use this jaxws dir for the build
1937 --with-override-hotspot use this hotspot dir for the build
1938 --with-override-nashorn use this nashorn dir for the build
1939 --with-override-jdk use this jdk dir for the build
1940 --with-import-hotspot import hotspot binaries from this jdk image or
1941 hotspot build dist dir instead of building from
1942 source
1943 --with-toolchain-type the toolchain type (or family) to use, use '--help'
1944 to show possible values [platform dependent]
1945 --with-toolchain-version
1946 the version of the toolchain to look for, use
1947 '--help' to show possible values [platform
1948 dependent]
1949 --with-jtreg Regression Test Harness [probed]
1950 --with-extra-cflags extra flags to be used when compiling jdk c-files
1951 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
1952 --with-extra-ldflags extra flags to be used when linking jdk
1953 --with-x use the X Window System
1954 --with-cups specify prefix directory for the cups package
1955 (expecting the headers under PATH/include)
1956 --with-cups-include specify directory for the cups include files
1957 --with-freetype specify prefix directory for the freetype package
1958 (expecting the libraries under PATH/lib and the
1959 headers under PATH/include)
1960 --with-freetype-include specify directory for the freetype include files
1961 --with-freetype-lib specify directory for the freetype library
1962 --with-freetype-src specify directory with freetype sources to
1963 automatically build the library (experimental,
1964 Windows-only)
1965 --with-alsa specify prefix directory for the alsa package
1966 (expecting the libraries under PATH/lib and the
1967 headers under PATH/include)
1968 --with-alsa-include specify directory for the alsa include files
1969 --with-alsa-lib specify directory for the alsa library
1970 --with-libjpeg use libjpeg from build system or OpenJDK source
1971 (system, bundled) [bundled]
1972 --with-giflib use giflib from build system or OpenJDK source
1973 (system, bundled) [bundled]
1974 --with-lcms use lcms2 from build system or OpenJDK source
1975 (system, bundled) [bundled]
1976 --with-libpng use libpng from build system or OpenJDK source
1977 (system, bundled) [bundled]
1978 --with-zlib use zlib from build system or OpenJDK source
1979 (system, bundled) [bundled]
1980 --with-stdc++lib=<static>,<dynamic>,<default>
1981 force linking of the C++ runtime on Linux to either
1982 static or dynamic, default is static with dynamic as
1983 fallback
1984 --with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
1985 (Windows only) [probed]
1986 --with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
1987 (Windows only) [probed]
1988 --with-dxsdk Deprecated. Option is kept for backwards
1989 compatibility and is ignored
1990 --with-dxsdk-lib Deprecated. Option is kept for backwards
1991 compatibility and is ignored
1992 --with-dxsdk-include Deprecated. Option is kept for backwards
1993 compatibility and is ignored
1994 --with-num-cores number of cores in the build system, e.g.
1995 --with-num-cores=8 [probed]
1996 --with-memory-size memory (in MB) available in the build system, e.g.
1997 --with-memory-size=1024 [probed]
1998 --with-jobs number of parallel jobs to let make run [calculated
1999 based on cores and memory]
2000 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2001 invocations of boot JDK, overriding the default
2002 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2003 -enableassertions"
2004 --with-sjavac-server-java
2005 use this java binary for running the sjavac
2006 background server [Boot JDK java]
2007 --with-ccache-dir where to store ccache files [~/.ccache]
2008
2009 Some influential environment variables:
2010 BASENAME Override default value for BASENAME
2011 BASH Override default value for BASH
2012 CAT Override default value for CAT
2013 CHMOD Override default value for CHMOD
2014 CMP Override default value for CMP
2015 COMM Override default value for COMM
2016 CP Override default value for CP
2017 CUT Override default value for CUT
2018 DATE Override default value for DATE
2019 DIFF Override default value for DIFF
2020 DIRNAME Override default value for DIRNAME
2021 ECHO Override default value for ECHO
2022 EXPR Override default value for EXPR
2023 FILE Override default value for FILE
2024 FIND Override default value for FIND
2025 HEAD Override default value for HEAD
2026 LN Override default value for LN
2027 LS Override default value for LS
2028 MKDIR Override default value for MKDIR
2029 MKTEMP Override default value for MKTEMP
2030 MV Override default value for MV
2031 NAWK Override default value for NAWK
2032 PRINTF Override default value for PRINTF
2033 RM Override default value for RM
2034 SH Override default value for SH
2035 SORT Override default value for SORT
2036 TAIL Override default value for TAIL
2037 TAR Override default value for TAR
2038 TEE Override default value for TEE
2039 TOUCH Override default value for TOUCH
2040 TR Override default value for TR
2041 UNAME Override default value for UNAME
2042 UNIQ Override default value for UNIQ
2043 WC Override default value for WC
2044 WHICH Override default value for WHICH
2045 XARGS Override default value for XARGS
2046 AWK Override default value for AWK
2047 GREP Override default value for GREP
2048 EGREP Override default value for EGREP
2049 FGREP Override default value for FGREP
2050 SED Override default value for SED
2051 CYGPATH Override default value for CYGPATH
2052 READLINK Override default value for READLINK
2053 DF Override default value for DF
2054 SETFILE Override default value for SETFILE
2055 CPIO Override default value for CPIO
2056 UNZIP Override default value for UNZIP
2057 ZIP Override default value for ZIP
2058 LDD Override default value for LDD
2059 OTOOL Override default value for OTOOL
2060 READELF Override default value for READELF
2061 HG Override default value for HG
2062 STAT Override default value for STAT
2063 TIME Override default value for TIME
2064 DSYMUTIL Override default value for DSYMUTIL
2065 XATTR Override default value for XATTR
2066 CODESIGN Override default value for CODESIGN
2067 PKG_CONFIG path to pkg-config utility
2068 JAVA Override default value for JAVA
2069 JAVAC Override default value for JAVAC
2070 JAVAH Override default value for JAVAH
2071 JAR Override default value for JAR
2072 JARSIGNER Override default value for JARSIGNER
2073 CC C compiler command
2074 CFLAGS C compiler flags
2075 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
2076 nonstandard directory <lib dir>
2077 LIBS libraries to pass to the linker, e.g. -l<library>
2078 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2079 you have headers in a nonstandard directory <include dir>
2080 CXX C++ compiler command
2081 CXXFLAGS C++ compiler flags
2082 CPP C preprocessor
2083 CXXCPP C++ preprocessor
2084 AS Override default value for AS
2085 AR Override default value for AR
2086 LIPO Override default value for LIPO
2087 STRIP Override default value for STRIP
2088 NM Override default value for NM
2089 GNM Override default value for GNM
2090 OBJCOPY Override default value for OBJCOPY
2091 OBJDUMP Override default value for OBJDUMP
2092 BUILD_CC Override default value for BUILD_CC
2093 BUILD_CXX Override default value for BUILD_CXX
2094 BUILD_LD Override default value for BUILD_LD
2095 JTREGEXE Override default value for JTREGEXE
2096 XMKMF Path to xmkmf, Makefile generator for X Window System
2097 FREETYPE_CFLAGS
2098 C compiler flags for FREETYPE, overriding pkg-config
2099 FREETYPE_LIBS
2100 linker flags for FREETYPE, overriding pkg-config
2101 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2102 ALSA_LIBS linker flags for ALSA, overriding pkg-config
2103 LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2104 LCMS_LIBS linker flags for LCMS, overriding pkg-config
2105 PNG_CFLAGS C compiler flags for PNG, overriding pkg-config
2106 PNG_LIBS linker flags for PNG, overriding pkg-config
2107 LIBFFI_CFLAGS
2108 C compiler flags for LIBFFI, overriding pkg-config
2109 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2110 CCACHE Override default value for CCACHE
2111
2112 Use these variables to override the choices made by `configure' or to help
2113 it to find libraries and programs with nonstandard names/locations.
2114
2115 Report bugs to <build-dev@openjdk.java.net>.
2116 OpenJDK home page: <http://openjdk.java.net>.
2117 _ACEOF
2118 ac_status=$?
2119 fi
2120
2121 if test "$ac_init_help" = "recursive"; then
2122 # If there are subdirs, report their specific --help.
2123 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2124 test -d "$ac_dir" ||
2125 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2126 continue
2127 ac_builddir=.
2128
2129 case "$ac_dir" in
2130 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2131 *)
2132 ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2133 # A ".." for each directory in $ac_dir_suffix.
2134 ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2135 case $ac_top_builddir_sub in
2136 "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2137 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2138 esac ;;
2139 esac
2140 ac_abs_top_builddir=$ac_pwd
2141 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2142 # for backward compatibility:
2143 ac_top_builddir=$ac_top_build_prefix
2144
2145 case $srcdir in
2146 .) # We are building in place.
2147 ac_srcdir=.
2148 ac_top_srcdir=$ac_top_builddir_sub
2149 ac_abs_top_srcdir=$ac_pwd ;;
2150 [\\/]* | ?:[\\/]* ) # Absolute name.
2151 ac_srcdir=$srcdir$ac_dir_suffix;
2152 ac_top_srcdir=$srcdir
2153 ac_abs_top_srcdir=$srcdir ;;
2154 *) # Relative name.
2155 ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2156 ac_top_srcdir=$ac_top_build_prefix$srcdir
2157 ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2158 esac
2159 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2160
2161 cd "$ac_dir" || { ac_status=$?; continue; }
2162 # Check for guested configure.
2163 if test -f "$ac_srcdir/configure.gnu"; then
2164 echo &&
2165 $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2166 elif test -f "$ac_srcdir/configure"; then
2167 echo &&
2168 $SHELL "$ac_srcdir/configure" --help=recursive
2169 else
2170 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2171 fi || ac_status=$?
2172 cd "$ac_pwd" || { ac_status=$?; break; }
2173 done
2174 fi
2175
2176 test -n "$ac_init_help" && exit $ac_status
2177 if $ac_init_version; then
2178 cat <<\_ACEOF
2179 OpenJDK configure jdk9
2180 generated by GNU Autoconf 2.69
2181
2182 Copyright (C) 2012 Free Software Foundation, Inc.
2183 This configure script is free software; the Free Software Foundation
2184 gives unlimited permission to copy, distribute and modify it.
2185 _ACEOF
2186 exit
2187 fi
2188
2189 ## ------------------------ ##
2190 ## Autoconf initialization. ##
2191 ## ------------------------ ##
2192
2193 # ac_fn_c_try_compile LINENO
2194 # --------------------------
2195 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2196 ac_fn_c_try_compile ()
2197 {
2198 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2199 rm -f conftest.$ac_objext
2200 if { { ac_try="$ac_compile"
2201 case "(($ac_try" in
2202 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2203 *) ac_try_echo=$ac_try;;
2204 esac
2205 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2206 $as_echo "$ac_try_echo"; } >&5
2207 (eval "$ac_compile") 2>conftest.err
2208 ac_status=$?
2209 if test -s conftest.err; then
2210 grep -v '^ *+' conftest.err >conftest.er1
2211 cat conftest.er1 >&5
2212 mv -f conftest.er1 conftest.err
2213 fi
2214 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2215 test $ac_status = 0; } && {
2216 test -z "$ac_c_werror_flag" ||
2217 test ! -s conftest.err
2218 } && test -s conftest.$ac_objext; then :
2219 ac_retval=0
2220 else
2221 $as_echo "$as_me: failed program was:" >&5
2222 sed 's/^/| /' conftest.$ac_ext >&5
2223
2224 ac_retval=1
2225 fi
2226 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2227 as_fn_set_status $ac_retval
2228
2229 } # ac_fn_c_try_compile
2230
2231 # ac_fn_cxx_try_compile LINENO
2232 # ----------------------------
2233 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2234 ac_fn_cxx_try_compile ()
2235 {
2236 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2237 rm -f conftest.$ac_objext
2238 if { { ac_try="$ac_compile"
2239 case "(($ac_try" in
2240 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2241 *) ac_try_echo=$ac_try;;
2242 esac
2243 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2244 $as_echo "$ac_try_echo"; } >&5
2245 (eval "$ac_compile") 2>conftest.err
2246 ac_status=$?
2247 if test -s conftest.err; then
2248 grep -v '^ *+' conftest.err >conftest.er1
2249 cat conftest.er1 >&5
2250 mv -f conftest.er1 conftest.err
2251 fi
2252 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2253 test $ac_status = 0; } && {
2254 test -z "$ac_cxx_werror_flag" ||
2255 test ! -s conftest.err
2256 } && test -s conftest.$ac_objext; then :
2257 ac_retval=0
2258 else
2259 $as_echo "$as_me: failed program was:" >&5
2260 sed 's/^/| /' conftest.$ac_ext >&5
2261
2262 ac_retval=1
2263 fi
2264 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2265 as_fn_set_status $ac_retval
2266
2267 } # ac_fn_cxx_try_compile
2268
2269 # ac_fn_c_try_cpp LINENO
2270 # ----------------------
2271 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2272 ac_fn_c_try_cpp ()
2273 {
2274 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2275 if { { ac_try="$ac_cpp conftest.$ac_ext"
2276 case "(($ac_try" in
2277 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2278 *) ac_try_echo=$ac_try;;
2279 esac
2280 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2281 $as_echo "$ac_try_echo"; } >&5
2282 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2283 ac_status=$?
2284 if test -s conftest.err; then
2285 grep -v '^ *+' conftest.err >conftest.er1
2286 cat conftest.er1 >&5
2287 mv -f conftest.er1 conftest.err
2288 fi
2289 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2290 test $ac_status = 0; } > conftest.i && {
2291 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2292 test ! -s conftest.err
2293 }; then :
2294 ac_retval=0
2295 else
2296 $as_echo "$as_me: failed program was:" >&5
2297 sed 's/^/| /' conftest.$ac_ext >&5
2298
2299 ac_retval=1
2300 fi
2301 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2302 as_fn_set_status $ac_retval
2303
2304 } # ac_fn_c_try_cpp
2305
2306 # ac_fn_cxx_try_cpp LINENO
2307 # ------------------------
2308 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2309 ac_fn_cxx_try_cpp ()
2310 {
2311 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2312 if { { ac_try="$ac_cpp conftest.$ac_ext"
2313 case "(($ac_try" in
2314 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2315 *) ac_try_echo=$ac_try;;
2316 esac
2317 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2318 $as_echo "$ac_try_echo"; } >&5
2319 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2320 ac_status=$?
2321 if test -s conftest.err; then
2322 grep -v '^ *+' conftest.err >conftest.er1
2323 cat conftest.er1 >&5
2324 mv -f conftest.er1 conftest.err
2325 fi
2326 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2327 test $ac_status = 0; } > conftest.i && {
2328 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2329 test ! -s conftest.err
2330 }; then :
2331 ac_retval=0
2332 else
2333 $as_echo "$as_me: failed program was:" >&5
2334 sed 's/^/| /' conftest.$ac_ext >&5
2335
2336 ac_retval=1
2337 fi
2338 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2339 as_fn_set_status $ac_retval
2340
2341 } # ac_fn_cxx_try_cpp
2342
2343 # ac_fn_c_try_link LINENO
2344 # -----------------------
2345 # Try to link conftest.$ac_ext, and return whether this succeeded.
2346 ac_fn_c_try_link ()
2347 {
2348 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2349 rm -f conftest.$ac_objext conftest$ac_exeext
2350 if { { ac_try="$ac_link"
2351 case "(($ac_try" in
2352 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2353 *) ac_try_echo=$ac_try;;
2354 esac
2355 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2356 $as_echo "$ac_try_echo"; } >&5
2357 (eval "$ac_link") 2>conftest.err
2358 ac_status=$?
2359 if test -s conftest.err; then
2360 grep -v '^ *+' conftest.err >conftest.er1
2361 cat conftest.er1 >&5
2362 mv -f conftest.er1 conftest.err
2363 fi
2364 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2365 test $ac_status = 0; } && {
2366 test -z "$ac_c_werror_flag" ||
2367 test ! -s conftest.err
2368 } && test -s conftest$ac_exeext && {
2369 test "$cross_compiling" = yes ||
2370 test -x conftest$ac_exeext
2371 }; then :
2372 ac_retval=0
2373 else
2374 $as_echo "$as_me: failed program was:" >&5
2375 sed 's/^/| /' conftest.$ac_ext >&5
2376
2377 ac_retval=1
2378 fi
2379 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2380 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2381 # interfere with the next link command; also delete a directory that is
2382 # left behind by Apple's compiler. We do this before executing the actions.
2383 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2384 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2385 as_fn_set_status $ac_retval
2386
2387 } # ac_fn_c_try_link
2388
2389 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2390 # ---------------------------------------------------------
2391 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2392 # the include files in INCLUDES and setting the cache variable VAR
2393 # accordingly.
2394 ac_fn_cxx_check_header_mongrel ()
2395 {
2396 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2397 if eval \${$3+:} false; then :
2398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2399 $as_echo_n "checking for $2... " >&6; }
2400 if eval \${$3+:} false; then :
2401 $as_echo_n "(cached) " >&6
2402 fi
2403 eval ac_res=\$$3
2404 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2405 $as_echo "$ac_res" >&6; }
2406 else
2407 # Is the header compilable?
2408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2409 $as_echo_n "checking $2 usability... " >&6; }
2410 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2411 /* end confdefs.h. */
2412 $4
2413 #include <$2>
2414 _ACEOF
2415 if ac_fn_cxx_try_compile "$LINENO"; then :
2416 ac_header_compiler=yes
2417 else
2418 ac_header_compiler=no
2419 fi
2420 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2422 $as_echo "$ac_header_compiler" >&6; }
2423
2424 # Is the header present?
2425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2426 $as_echo_n "checking $2 presence... " >&6; }
2427 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2428 /* end confdefs.h. */
2429 #include <$2>
2430 _ACEOF
2431 if ac_fn_cxx_try_cpp "$LINENO"; then :
2432 ac_header_preproc=yes
2433 else
2434 ac_header_preproc=no
2435 fi
2436 rm -f conftest.err conftest.i conftest.$ac_ext
2437 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2438 $as_echo "$ac_header_preproc" >&6; }
2439
2440 # So? What about this header?
2441 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2442 yes:no: )
2443 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2444 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2445 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2446 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2447 ;;
2448 no:yes:* )
2449 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2450 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2451 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
2452 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
2453 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2454 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2455 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
2456 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
2457 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2458 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2459 ( $as_echo "## ----------------------------------------- ##
2460 ## Report this to build-dev@openjdk.java.net ##
2461 ## ----------------------------------------- ##"
2462 ) | sed "s/^/$as_me: WARNING: /" >&2
2463 ;;
2464 esac
2465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2466 $as_echo_n "checking for $2... " >&6; }
2467 if eval \${$3+:} false; then :
2468 $as_echo_n "(cached) " >&6
2469 else
2470 eval "$3=\$ac_header_compiler"
2471 fi
2472 eval ac_res=\$$3
2473 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2474 $as_echo "$ac_res" >&6; }
2475 fi
2476 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2477
2478 } # ac_fn_cxx_check_header_mongrel
2479
2480 # ac_fn_cxx_try_run LINENO
2481 # ------------------------
2482 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2483 # that executables *can* be run.
2484 ac_fn_cxx_try_run ()
2485 {
2486 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2487 if { { ac_try="$ac_link"
2488 case "(($ac_try" in
2489 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2490 *) ac_try_echo=$ac_try;;
2491 esac
2492 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2493 $as_echo "$ac_try_echo"; } >&5
2494 (eval "$ac_link") 2>&5
2495 ac_status=$?
2496 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2497 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2498 { { case "(($ac_try" in
2499 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2500 *) ac_try_echo=$ac_try;;
2501 esac
2502 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2503 $as_echo "$ac_try_echo"; } >&5
2504 (eval "$ac_try") 2>&5
2505 ac_status=$?
2506 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2507 test $ac_status = 0; }; }; then :
2508 ac_retval=0
2509 else
2510 $as_echo "$as_me: program exited with status $ac_status" >&5
2511 $as_echo "$as_me: failed program was:" >&5
2512 sed 's/^/| /' conftest.$ac_ext >&5
2513
2514 ac_retval=$ac_status
2515 fi
2516 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2517 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2518 as_fn_set_status $ac_retval
2519
2520 } # ac_fn_cxx_try_run
2521
2522 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2523 # ---------------------------------------------------------
2524 # Tests whether HEADER exists and can be compiled using the include files in
2525 # INCLUDES, setting the cache variable VAR accordingly.
2526 ac_fn_cxx_check_header_compile ()
2527 {
2528 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2530 $as_echo_n "checking for $2... " >&6; }
2531 if eval \${$3+:} false; then :
2532 $as_echo_n "(cached) " >&6
2533 else
2534 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2535 /* end confdefs.h. */
2536 $4
2537 #include <$2>
2538 _ACEOF
2539 if ac_fn_cxx_try_compile "$LINENO"; then :
2540 eval "$3=yes"
2541 else
2542 eval "$3=no"
2543 fi
2544 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2545 fi
2546 eval ac_res=\$$3
2547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2548 $as_echo "$ac_res" >&6; }
2549 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2550
2551 } # ac_fn_cxx_check_header_compile
2552
2553 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2554 # ----------------------------------------------
2555 # Tries to find the compile-time value of EXPR in a program that includes
2556 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2557 # computed
2558 ac_fn_cxx_compute_int ()
2559 {
2560 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2561 if test "$cross_compiling" = yes; then
2562 # Depending upon the size, compute the lo and hi bounds.
2563 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2564 /* end confdefs.h. */
2565 $4
2566 int
2567 main ()
2568 {
2569 static int test_array [1 - 2 * !(($2) >= 0)];
2570 test_array [0] = 0;
2571 return test_array [0];
2572
2573 ;
2574 return 0;
2575 }
2576 _ACEOF
2577 if ac_fn_cxx_try_compile "$LINENO"; then :
2578 ac_lo=0 ac_mid=0
2579 while :; do
2580 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2581 /* end confdefs.h. */
2582 $4
2583 int
2584 main ()
2585 {
2586 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2587 test_array [0] = 0;
2588 return test_array [0];
2589
2590 ;
2591 return 0;
2592 }
2593 _ACEOF
2594 if ac_fn_cxx_try_compile "$LINENO"; then :
2595 ac_hi=$ac_mid; break
2596 else
2597 as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2598 if test $ac_lo -le $ac_mid; then
2599 ac_lo= ac_hi=
2600 break
2601 fi
2602 as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2603 fi
2604 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2605 done
2606 else
2607 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2608 /* end confdefs.h. */
2609 $4
2610 int
2611 main ()
2612 {
2613 static int test_array [1 - 2 * !(($2) < 0)];
2614 test_array [0] = 0;
2615 return test_array [0];
2616
2617 ;
2618 return 0;
2619 }
2620 _ACEOF
2621 if ac_fn_cxx_try_compile "$LINENO"; then :
2622 ac_hi=-1 ac_mid=-1
2623 while :; do
2624 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2625 /* end confdefs.h. */
2626 $4
2627 int
2628 main ()
2629 {
2630 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2631 test_array [0] = 0;
2632 return test_array [0];
2633
2634 ;
2635 return 0;
2636 }
2637 _ACEOF
2638 if ac_fn_cxx_try_compile "$LINENO"; then :
2639 ac_lo=$ac_mid; break
2640 else
2641 as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2642 if test $ac_mid -le $ac_hi; then
2643 ac_lo= ac_hi=
2644 break
2645 fi
2646 as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2647 fi
2648 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2649 done
2650 else
2651 ac_lo= ac_hi=
2652 fi
2653 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2654 fi
2655 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2656 # Binary search between lo and hi bounds.
2657 while test "x$ac_lo" != "x$ac_hi"; do
2658 as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2659 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2660 /* end confdefs.h. */
2661 $4
2662 int
2663 main ()
2664 {
2665 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2666 test_array [0] = 0;
2667 return test_array [0];
2668
2669 ;
2670 return 0;
2671 }
2672 _ACEOF
2673 if ac_fn_cxx_try_compile "$LINENO"; then :
2674 ac_hi=$ac_mid
2675 else
2676 as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2677 fi
2678 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2679 done
2680 case $ac_lo in #((
2681 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2682 '') ac_retval=1 ;;
2683 esac
2684 else
2685 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2686 /* end confdefs.h. */
2687 $4
2688 static long int longval () { return $2; }
2689 static unsigned long int ulongval () { return $2; }
2690 #include <stdio.h>
2691 #include <stdlib.h>
2692 int
2693 main ()
2694 {
2695
2696 FILE *f = fopen ("conftest.val", "w");
2697 if (! f)
2698 return 1;
2699 if (($2) < 0)
2700 {
2701 long int i = longval ();
2702 if (i != ($2))
2703 return 1;
2704 fprintf (f, "%ld", i);
2705 }
2706 else
2707 {
2708 unsigned long int i = ulongval ();
2709 if (i != ($2))
2710 return 1;
2711 fprintf (f, "%lu", i);
2712 }
2713 /* Do not output a trailing newline, as this causes \r\n confusion
2714 on some platforms. */
2715 return ferror (f) || fclose (f) != 0;
2716
2717 ;
2718 return 0;
2719 }
2720 _ACEOF
2721 if ac_fn_cxx_try_run "$LINENO"; then :
2722 echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2723 else
2724 ac_retval=1
2725 fi
2726 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2727 conftest.$ac_objext conftest.beam conftest.$ac_ext
2728 rm -f conftest.val
2729
2730 fi
2731 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2732 as_fn_set_status $ac_retval
2733
2734 } # ac_fn_cxx_compute_int
2735
2736 # ac_fn_cxx_try_link LINENO
2737 # -------------------------
2738 # Try to link conftest.$ac_ext, and return whether this succeeded.
2739 ac_fn_cxx_try_link ()
2740 {
2741 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2742 rm -f conftest.$ac_objext conftest$ac_exeext
2743 if { { ac_try="$ac_link"
2744 case "(($ac_try" in
2745 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2746 *) ac_try_echo=$ac_try;;
2747 esac
2748 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2749 $as_echo "$ac_try_echo"; } >&5
2750 (eval "$ac_link") 2>conftest.err
2751 ac_status=$?
2752 if test -s conftest.err; then
2753 grep -v '^ *+' conftest.err >conftest.er1
2754 cat conftest.er1 >&5
2755 mv -f conftest.er1 conftest.err
2756 fi
2757 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2758 test $ac_status = 0; } && {
2759 test -z "$ac_cxx_werror_flag" ||
2760 test ! -s conftest.err
2761 } && test -s conftest$ac_exeext && {
2762 test "$cross_compiling" = yes ||
2763 test -x conftest$ac_exeext
2764 }; then :
2765 ac_retval=0
2766 else
2767 $as_echo "$as_me: failed program was:" >&5
2768 sed 's/^/| /' conftest.$ac_ext >&5
2769
2770 ac_retval=1
2771 fi
2772 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2773 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2774 # interfere with the next link command; also delete a directory that is
2775 # left behind by Apple's compiler. We do this before executing the actions.
2776 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2777 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2778 as_fn_set_status $ac_retval
2779
2780 } # ac_fn_cxx_try_link
2781
2782 # ac_fn_cxx_check_func LINENO FUNC VAR
2783 # ------------------------------------
2784 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2785 ac_fn_cxx_check_func ()
2786 {
2787 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2789 $as_echo_n "checking for $2... " >&6; }
2790 if eval \${$3+:} false; then :
2791 $as_echo_n "(cached) " >&6
2792 else
2793 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2794 /* end confdefs.h. */
2795 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2796 For example, HP-UX 11i <limits.h> declares gettimeofday. */
2797 #define $2 innocuous_$2
2798
2799 /* System header to define __stub macros and hopefully few prototypes,
2800 which can conflict with char $2 (); below.
2801 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2802 <limits.h> exists even on freestanding compilers. */
2803
2804 #ifdef __STDC__
2805 # include <limits.h>
2806 #else
2807 # include <assert.h>
2808 #endif
2809
2810 #undef $2
2811
2812 /* Override any GCC internal prototype to avoid an error.
2813 Use char because int might match the return type of a GCC
2814 builtin and then its argument prototype would still apply. */
2815 #ifdef __cplusplus
2816 extern "C"
2817 #endif
2818 char $2 ();
2819 /* The GNU C library defines this for functions which it implements
2820 to always fail with ENOSYS. Some functions are actually named
2821 something starting with __ and the normal name is an alias. */
2822 #if defined __stub_$2 || defined __stub___$2
2823 choke me
2824 #endif
2825
2826 int
2827 main ()
2828 {
2829 return $2 ();
2830 ;
2831 return 0;
2832 }
2833 _ACEOF
2834 if ac_fn_cxx_try_link "$LINENO"; then :
2835 eval "$3=yes"
2836 else
2837 eval "$3=no"
2838 fi
2839 rm -f core conftest.err conftest.$ac_objext \
2840 conftest$ac_exeext conftest.$ac_ext
2841 fi
2842 eval ac_res=\$$3
2843 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2844 $as_echo "$ac_res" >&6; }
2845 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2846
2847 } # ac_fn_cxx_check_func
2848
2849 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2850 # -------------------------------------------------------
2851 # Tests whether HEADER exists and can be compiled using the include files in
2852 # INCLUDES, setting the cache variable VAR accordingly.
2853 ac_fn_c_check_header_compile ()
2854 {
2855 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2856 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2857 $as_echo_n "checking for $2... " >&6; }
2858 if eval \${$3+:} false; then :
2859 $as_echo_n "(cached) " >&6
2860 else
2861 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2862 /* end confdefs.h. */
2863 $4
2864 #include <$2>
2865 _ACEOF
2866 if ac_fn_c_try_compile "$LINENO"; then :
2867 eval "$3=yes"
2868 else
2869 eval "$3=no"
2870 fi
2871 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2872 fi
2873 eval ac_res=\$$3
2874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2875 $as_echo "$ac_res" >&6; }
2876 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2877
2878 } # ac_fn_c_check_header_compile
2879 cat >config.log <<_ACEOF
2880 This file contains any messages produced by compilers while
2881 running configure, to aid debugging if configure makes a mistake.
2882
2883 It was created by OpenJDK $as_me jdk9, which was
2884 generated by GNU Autoconf 2.69. Invocation command line was
2885
2886 $ $0 $@
2887
2888 _ACEOF
2889 exec 5>>config.log
2890 {
2891 cat <<_ASUNAME
2892 ## --------- ##
2893 ## Platform. ##
2894 ## --------- ##
2895
2896 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2897 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2898 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2899 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2900 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2901
2902 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2903 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
2904
2905 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
2906 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
2907 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2908 /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
2909 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
2910 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
2911 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
2912
2913 _ASUNAME
2914
2915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2916 for as_dir in $PATH
2917 do
2918 IFS=$as_save_IFS
2919 test -z "$as_dir" && as_dir=.
2920 $as_echo "PATH: $as_dir"
2921 done
2922 IFS=$as_save_IFS
2923
2924 } >&5
2925
2926 cat >&5 <<_ACEOF
2927
2928
2929 ## ----------- ##
2930 ## Core tests. ##
2931 ## ----------- ##
2932
2933 _ACEOF
2934
2935
2936 # Keep a trace of the command line.
2937 # Strip out --no-create and --no-recursion so they do not pile up.
2938 # Strip out --silent because we don't want to record it for future runs.
2939 # Also quote any args containing shell meta-characters.
2940 # Make two passes to allow for proper duplicate-argument suppression.
2941 ac_configure_args=
2942 ac_configure_args0=
2943 ac_configure_args1=
2944 ac_must_keep_next=false
2945 for ac_pass in 1 2
2946 do
2947 for ac_arg
2948 do
2949 case $ac_arg in
2950 -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2951 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2952 | -silent | --silent | --silen | --sile | --sil)
2953 continue ;;
2954 *\'*)
2955 ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2956 esac
2957 case $ac_pass in
2958 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2959 2)
2960 as_fn_append ac_configure_args1 " '$ac_arg'"
2961 if test $ac_must_keep_next = true; then
2962 ac_must_keep_next=false # Got value, back to normal.
2963 else
2964 case $ac_arg in
2965 *=* | --config-cache | -C | -disable-* | --disable-* \
2966 | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2967 | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2968 | -with-* | --with-* | -without-* | --without-* | --x)
2969 case "$ac_configure_args0 " in
2970 "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2971 esac
2972 ;;
2973 -* ) ac_must_keep_next=true ;;
2974 esac
2975 fi
2976 as_fn_append ac_configure_args " '$ac_arg'"
2977 ;;
2978 esac
2979 done
2980 done
2981 { ac_configure_args0=; unset ac_configure_args0;}
2982 { ac_configure_args1=; unset ac_configure_args1;}
2983
2984 # When interrupted or exit'd, cleanup temporary files, and complete
2985 # config.log. We remove comments because anyway the quotes in there
2986 # would cause problems or look ugly.
2987 # WARNING: Use '\'' to represent an apostrophe within the trap.
2988 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2989 trap 'exit_status=$?
2990 # Save into config.log some information that might help in debugging.
2991 {
2992 echo
2993
2994 $as_echo "## ---------------- ##
2995 ## Cache variables. ##
2996 ## ---------------- ##"
2997 echo
2998 # The following way of writing the cache mishandles newlines in values,
2999 (
3000 for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3001 eval ac_val=\$$ac_var
3002 case $ac_val in #(
3003 *${as_nl}*)
3004 case $ac_var in #(
3005 *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3006 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3007 esac
3008 case $ac_var in #(
3009 _ | IFS | as_nl) ;; #(
3010 BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3011 *) { eval $ac_var=; unset $ac_var;} ;;
3012 esac ;;
3013 esac
3014 done
3015 (set) 2>&1 |
3016 case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3017 *${as_nl}ac_space=\ *)
3018 sed -n \
3019 "s/'\''/'\''\\\\'\'''\''/g;
3020 s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3021 ;; #(
3022 *)
3023 sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3024 ;;
3025 esac |
3026 sort
3027 )
3028 echo
3029
3030 $as_echo "## ----------------- ##
3031 ## Output variables. ##
3032 ## ----------------- ##"
3033 echo
3034 for ac_var in $ac_subst_vars
3035 do
3036 eval ac_val=\$$ac_var
3037 case $ac_val in
3038 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3039 esac
3040 $as_echo "$ac_var='\''$ac_val'\''"
3041 done | sort
3042 echo
3043
3044 if test -n "$ac_subst_files"; then
3045 $as_echo "## ------------------- ##
3046 ## File substitutions. ##
3047 ## ------------------- ##"
3048 echo
3049 for ac_var in $ac_subst_files
3050 do
3051 eval ac_val=\$$ac_var
3052 case $ac_val in
3053 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3054 esac
3055 $as_echo "$ac_var='\''$ac_val'\''"
3056 done | sort
3057 echo
3058 fi
3059
3060 if test -s confdefs.h; then
3061 $as_echo "## ----------- ##
3062 ## confdefs.h. ##
3063 ## ----------- ##"
3064 echo
3065 cat confdefs.h
3066 echo
3067 fi
3068 test "$ac_signal" != 0 &&
3069 $as_echo "$as_me: caught signal $ac_signal"
3070 $as_echo "$as_me: exit $exit_status"
3071 } >&5
3072 rm -f core *.core core.conftest.* &&
3073 rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3074 exit $exit_status
3075 ' 0
3076 for ac_signal in 1 2 13 15; do
3077 trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3078 done
3079 ac_signal=0
3080
3081 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3082 rm -f -r conftest* confdefs.h
3083
3084 $as_echo "/* confdefs.h */" > confdefs.h
3085
3086 # Predefined preprocessor variables.
3087
3088 cat >>confdefs.h <<_ACEOF
3089 #define PACKAGE_NAME "$PACKAGE_NAME"
3090 _ACEOF
3091
3092 cat >>confdefs.h <<_ACEOF
3093 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3094 _ACEOF
3095
3096 cat >>confdefs.h <<_ACEOF
3097 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3098 _ACEOF
3099
3100 cat >>confdefs.h <<_ACEOF
3101 #define PACKAGE_STRING "$PACKAGE_STRING"
3102 _ACEOF
3103
3104 cat >>confdefs.h <<_ACEOF
3105 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3106 _ACEOF
3107
3108 cat >>confdefs.h <<_ACEOF
3109 #define PACKAGE_URL "$PACKAGE_URL"
3110 _ACEOF
3111
3112
3113 # Let the site file select an alternate cache file if it wants to.
3114 # Prefer an explicitly selected file to automatically selected ones.
3115 ac_site_file1=NONE
3116 ac_site_file2=NONE
3117 if test -n "$CONFIG_SITE"; then
3118 # We do not want a PATH search for config.site.
3119 case $CONFIG_SITE in #((
3120 -*) ac_site_file1=./$CONFIG_SITE;;
3121 */*) ac_site_file1=$CONFIG_SITE;;
3122 *) ac_site_file1=./$CONFIG_SITE;;
3123 esac
3124 elif test "x$prefix" != xNONE; then
3125 ac_site_file1=$prefix/share/config.site
3126 ac_site_file2=$prefix/etc/config.site
3127 else
3128 ac_site_file1=$ac_default_prefix/share/config.site
3129 ac_site_file2=$ac_default_prefix/etc/config.site
3130 fi
3131 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3132 do
3133 test "x$ac_site_file" = xNONE && continue
3134 if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3135 { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3136 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3137 sed 's/^/| /' "$ac_site_file" >&5
3138 . "$ac_site_file" \
3139 || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3140 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3141 as_fn_error $? "failed to load site script $ac_site_file
3142 See \`config.log' for more details" "$LINENO" 5; }
3143 fi
3144 done
3145
3146 if test -r "$cache_file"; then
3147 # Some versions of bash will fail to source /dev/null (special files
3148 # actually), so we avoid doing that. DJGPP emulates it as a regular file.
3149 if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3150 { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3151 $as_echo "$as_me: loading cache $cache_file" >&6;}
3152 case $cache_file in
3153 [\\/]* | ?:[\\/]* ) . "$cache_file";;
3154 *) . "./$cache_file";;
3155 esac
3156 fi
3157 else
3158 { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3159 $as_echo "$as_me: creating cache $cache_file" >&6;}
3160 >$cache_file
3161 fi
3162
3163 # Check that the precious variables saved in the cache have kept the same
3164 # value.
3165 ac_cache_corrupted=false
3166 for ac_var in $ac_precious_vars; do
3167 eval ac_old_set=\$ac_cv_env_${ac_var}_set
3168 eval ac_new_set=\$ac_env_${ac_var}_set
3169 eval ac_old_val=\$ac_cv_env_${ac_var}_value
3170 eval ac_new_val=\$ac_env_${ac_var}_value
3171 case $ac_old_set,$ac_new_set in
3172 set,)
3173 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3174 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3175 ac_cache_corrupted=: ;;
3176 ,set)
3177 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3178 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3179 ac_cache_corrupted=: ;;
3180 ,);;
3181 *)
3182 if test "x$ac_old_val" != "x$ac_new_val"; then
3183 # differences in whitespace do not lead to failure.
3184 ac_old_val_w=`echo x $ac_old_val`
3185 ac_new_val_w=`echo x $ac_new_val`
3186 if test "$ac_old_val_w" != "$ac_new_val_w"; then
3187 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3188 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3189 ac_cache_corrupted=:
3190 else
3191 { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3192 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3193 eval $ac_var=\$ac_old_val
3194 fi
3195 { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
3196 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
3197 { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
3198 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
3199 fi;;
3200 esac
3201 # Pass precious variables to config.status.
3202 if test "$ac_new_set" = set; then
3203 case $ac_new_val in
3204 *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3205 *) ac_arg=$ac_var=$ac_new_val ;;
3206 esac
3207 case " $ac_configure_args " in
3208 *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
3209 *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3210 esac
3211 fi
3212 done
3213 if $ac_cache_corrupted; then
3214 { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3215 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3216 { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3217 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3218 as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3219 fi
3220 ## -------------------- ##
3221 ## Main body of script. ##
3222 ## -------------------- ##
3223
3224 ac_ext=c
3225 ac_cpp='$CPP $CPPFLAGS'
3226 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3227 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3228 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3229
3230
3231
3232 ac_aux_dir=
3233 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3234 if test -f "$ac_dir/install-sh"; then
3235 ac_aux_dir=$ac_dir
3236 ac_install_sh="$ac_aux_dir/install-sh -c"
3237 break
3238 elif test -f "$ac_dir/install.sh"; then
3239 ac_aux_dir=$ac_dir
3240 ac_install_sh="$ac_aux_dir/install.sh -c"
3241 break
3242 elif test -f "$ac_dir/shtool"; then
3243 ac_aux_dir=$ac_dir
3244 ac_install_sh="$ac_aux_dir/shtool install -c"
3245 break
3246 fi
3247 done
3248 if test -z "$ac_aux_dir"; then
3249 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
3250 fi
3251
3252 # These three variables are undocumented and unsupported,
3253 # and are intended to be withdrawn in a future Autoconf release.
3254 # They can cause serious problems if a builder's source tree is in a directory
3255 # whose full name contains unusual characters.
3256 ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
3257 ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
3258 ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
3259
3260
3261 # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
3262
3263 #
3264 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3265 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3266 #
3267 # This code is free software; you can redistribute it and/or modify it
3268 # under the terms of the GNU General Public License version 2 only, as
3269 # published by the Free Software Foundation. Oracle designates this
3270 # particular file as subject to the "Classpath" exception as provided
3271 # by Oracle in the LICENSE file that accompanied this code.
3272 #
3273 # This code is distributed in the hope that it will be useful, but WITHOUT
3274 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3275 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3276 # version 2 for more details (a copy is included in the LICENSE file that
3277 # accompanied this code).
3278 #
3279 # You should have received a copy of the GNU General Public License version
3280 # 2 along with this work; if not, write to the Free Software Foundation,
3281 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3282 #
3283 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3284 # or visit www.oracle.com if you need additional information or have any
3285 # questions.
3286 #
3287
3288 #
3289 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3290 #
3291 # This program is free software; you can redistribute it and/or modify
3292 # it under the terms of the GNU General Public License as published by
3293 # the Free Software Foundation; either version 2 of the License, or
3294 # (at your option) any later version.
3295 #
3296 # This program is distributed in the hope that it will be useful, but
3297 # WITHOUT ANY WARRANTY; without even the implied warranty of
3298 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3299 # General Public License for more details.
3300 #
3301 # You should have received a copy of the GNU General Public License
3302 # along with this program; if not, write to the Free Software
3303 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3304 #
3305 # As a special exception to the GNU General Public License, if you
3306 # distribute this file as part of a program that contains a
3307 # configuration script generated by Autoconf, you may include it under
3308 # the same distribution terms that you use for the rest of that program.
3309
3310 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3311 # ----------------------------------
3312 # PKG_PROG_PKG_CONFIG
3313
3314 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3315 #
3316 # Check to see whether a particular set of modules exists. Similar
3317 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3318 #
3319 #
3320 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3321 # this or PKG_CHECK_MODULES is called, or make sure to call
3322 # PKG_CHECK_EXISTS manually
3323 # --------------------------------------------------------------
3324
3325
3326
3327 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3328 # ---------------------------------------------
3329 # _PKG_CONFIG
3330
3331 # _PKG_SHORT_ERRORS_SUPPORTED
3332 # -----------------------------
3333 # _PKG_SHORT_ERRORS_SUPPORTED
3334
3335
3336 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3337 # [ACTION-IF-NOT-FOUND])
3338 #
3339 #
3340 # Note that if there is a possibility the first call to
3341 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3342 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3343 #
3344 #
3345 # --------------------------------------------------------------
3346 # PKG_CHECK_MODULES
3347
3348
3349 # Include these first...
3350 #
3351 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3352 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3353 #
3354 # This code is free software; you can redistribute it and/or modify it
3355 # under the terms of the GNU General Public License version 2 only, as
3356 # published by the Free Software Foundation. Oracle designates this
3357 # particular file as subject to the "Classpath" exception as provided
3358 # by Oracle in the LICENSE file that accompanied this code.
3359 #
3360 # This code is distributed in the hope that it will be useful, but WITHOUT
3361 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3362 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3363 # version 2 for more details (a copy is included in the LICENSE file that
3364 # accompanied this code).
3365 #
3366 # You should have received a copy of the GNU General Public License version
3367 # 2 along with this work; if not, write to the Free Software Foundation,
3368 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3369 #
3370 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3371 # or visit www.oracle.com if you need additional information or have any
3372 # questions.
3373 #
3374
3375 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3376 # If so, then append $1 to $2 \
3377 # Also set JVM_ARG_OK to true/false depending on outcome.
3378
3379
3380 # Appends a string to a path variable, only adding the : when needed.
3381
3382
3383 # Prepends a string to a path variable, only adding the : when needed.
3384
3385
3386 # This will make sure the given variable points to a full and proper
3387 # path. This means:
3388 # 1) There will be no spaces in the path. On unix platforms,
3389 # spaces in the path will result in an error. On Windows,
3390 # the path will be rewritten using short-style to be space-free.
3391 # 2) The path will be absolute, and it will be in unix-style (on
3392 # cygwin).
3393 # $1: The name of the variable to fix
3394
3395
3396 # This will make sure the given variable points to a executable
3397 # with a full and proper path. This means:
3398 # 1) There will be no spaces in the path. On unix platforms,
3399 # spaces in the path will result in an error. On Windows,
3400 # the path will be rewritten using short-style to be space-free.
3401 # 2) The path will be absolute, and it will be in unix-style (on
3402 # cygwin).
3403 # Any arguments given to the executable is preserved.
3404 # If the input variable does not have a directory specification, then
3405 # it need to be in the PATH.
3406 # $1: The name of the variable to fix
3407
3408
3409
3410
3411 # Register a --with argument but mark it as deprecated
3412 # $1: The name of the with argument to deprecate, not including --with-
3413
3414
3415 # Register a --enable argument but mark it as deprecated
3416 # $1: The name of the with argument to deprecate, not including --enable-
3417 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3418
3419
3420
3421
3422 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3423 # $1: variable to check
3424
3425
3426 # Check that there are no unprocessed overridden variables left.
3427 # If so, they are an incorrect argument and we will exit with an error.
3428
3429
3430 # Setup a tool for the given variable. If correctly specified by the user,
3431 # use that value, otherwise search for the tool using the supplied code snippet.
3432 # $1: variable to set
3433 # $2: code snippet to call to look for the tool
3434
3435
3436 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3437 # $1: variable to set
3438 # $2: executable name (or list of names) to look for
3439
3440
3441 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3442 # $1: variable to set
3443 # $2: executable name (or list of names) to look for
3444
3445
3446 # Like BASIC_PATH_PROGS but fails if no tool was found.
3447 # $1: variable to set
3448 # $2: executable name (or list of names) to look for
3449
3450
3451 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3452 # $1: variable to set
3453 # $2: autoconf macro to call to look for the special tool
3454
3455
3456 # Setup the most fundamental tools that relies on not much else to set up,
3457 # but is used by much of the early bootstrap code.
3458
3459
3460 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3461
3462
3463 # Evaluates platform specific overrides for devkit variables.
3464 # $1: Name of variable
3465
3466
3467
3468
3469
3470
3471 #%%% Simple tools %%%
3472
3473 # Check if we have found a usable version of make
3474 # $1: the path to a potential make binary (or empty)
3475 # $2: the description on how we found this
3476
3477
3478
3479
3480 # Goes looking for a usable version of GNU make.
3481
3482
3483
3484
3485
3486
3487 # Check if build directory is on local disk. If not possible to determine,
3488 # we prefer to claim it's local.
3489 # Argument 1: directory to test
3490 # Argument 2: what to do if it is on local disk
3491 # Argument 3: what to do otherwise (remote disk or failure)
3492
3493
3494 # Check that source files have basic read permissions set. This might
3495 # not be the case in cygwin in certain conditions.
3496
3497
3498
3499
3500 # Check for support for specific options in bash
3501
3502
3503 # Code to run after AC_OUTPUT
3504
3505
3506 #
3507 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3508 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3509 #
3510 # This code is free software; you can redistribute it and/or modify it
3511 # under the terms of the GNU General Public License version 2 only, as
3512 # published by the Free Software Foundation. Oracle designates this
3513 # particular file as subject to the "Classpath" exception as provided
3514 # by Oracle in the LICENSE file that accompanied this code.
3515 #
3516 # This code is distributed in the hope that it will be useful, but WITHOUT
3517 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3518 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3519 # version 2 for more details (a copy is included in the LICENSE file that
3520 # accompanied this code).
3521 #
3522 # You should have received a copy of the GNU General Public License version
3523 # 2 along with this work; if not, write to the Free Software Foundation,
3524 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3525 #
3526 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3527 # or visit www.oracle.com if you need additional information or have any
3528 # questions.
3529 #
3530
3531
3532
3533
3534
3535 # Helper function which possibly converts a path using DOS-style short mode.
3536 # If so, the updated path is stored in $new_path.
3537 # $1: The path to check
3538
3539
3540 # Helper function which possibly converts a path using DOS-style short mode.
3541 # If so, the updated path is stored in $new_path.
3542 # $1: The path to check
3543
3544
3545 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3546 # and could probably be heavily simplified. However, all changes in this
3547 # area tend to need lot of testing in different scenarios, and in lack of
3548 # proper unit testing, cleaning this up has not been deemed worth the effort
3549 # at the moment.
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3560
3561
3562
3563
3564 #
3565 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3566 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3567 #
3568 # This code is free software; you can redistribute it and/or modify it
3569 # under the terms of the GNU General Public License version 2 only, as
3570 # published by the Free Software Foundation. Oracle designates this
3571 # particular file as subject to the "Classpath" exception as provided
3572 # by Oracle in the LICENSE file that accompanied this code.
3573 #
3574 # This code is distributed in the hope that it will be useful, but WITHOUT
3575 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3576 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3577 # version 2 for more details (a copy is included in the LICENSE file that
3578 # accompanied this code).
3579 #
3580 # You should have received a copy of the GNU General Public License version
3581 # 2 along with this work; if not, write to the Free Software Foundation,
3582 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3583 #
3584 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3585 # or visit www.oracle.com if you need additional information or have any
3586 # questions.
3587 #
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599 # ... then the rest
3600 #
3601 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3602 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3603 #
3604 # This code is free software; you can redistribute it and/or modify it
3605 # under the terms of the GNU General Public License version 2 only, as
3606 # published by the Free Software Foundation. Oracle designates this
3607 # particular file as subject to the "Classpath" exception as provided
3608 # by Oracle in the LICENSE file that accompanied this code.
3609 #
3610 # This code is distributed in the hope that it will be useful, but WITHOUT
3611 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3612 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3613 # version 2 for more details (a copy is included in the LICENSE file that
3614 # accompanied this code).
3615 #
3616 # You should have received a copy of the GNU General Public License version
3617 # 2 along with this work; if not, write to the Free Software Foundation,
3618 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3619 #
3620 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3621 # or visit www.oracle.com if you need additional information or have any
3622 # questions.
3623 #
3624
3625 ########################################################################
3626 # This file handles detection of the Boot JDK. The Boot JDK detection
3627 # process has been developed as a response to solve a complex real-world
3628 # problem. Initially, it was simple, but it has grown as platform after
3629 # platform, idiosyncracy after idiosyncracy has been supported.
3630 #
3631 # The basic idea is this:
3632 # 1) You need an acceptable *) JDK to use as a Boot JDK
3633 # 2) There are several ways to locate a JDK, that are mostly platform
3634 # dependent **)
3635 # 3) You can have multiple JDKs installed
3636 # 4) If possible, configure should try to dig out an acceptable JDK
3637 # automatically, without having to resort to command-line options
3638 #
3639 # *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3640 # javac) and not a JRE, etc.
3641 #
3642 # **) On Windows we typically use a well-known path.
3643 # On MacOSX we typically use the tool java_home.
3644 # On Linux we typically find javac in the $PATH, and then follow a
3645 # chain of symlinks that often ends up in a real JDK.
3646 #
3647 # This leads to the code where we check in different ways to locate a
3648 # JDK, and if one is found, check if it is acceptable. If not, we print
3649 # our reasons for rejecting it (useful when debugging non-working
3650 # configure situations) and continue checking the next one.
3651 ########################################################################
3652
3653 # Execute the check given as argument, and verify the result
3654 # If the Boot JDK was previously found, do nothing
3655 # $1 A command line (typically autoconf macro) to execute
3656
3657
3658 # Test: Is bootjdk explicitely set by command line arguments?
3659
3660
3661 # Test: Is bootjdk available from builddeps?
3662
3663
3664 # Test: Is $JAVA_HOME set?
3665
3666
3667 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3668
3669
3670 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3671 # $1: Argument to the java_home binary (optional)
3672
3673
3674 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3675
3676
3677 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3678 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3679 # $1 = Path to directory containing jdk installations.
3680 # $2 = String to append to the found JDK directory to get the proper JDK home
3681
3682
3683 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3684 # environmental variable as base for where to look.
3685 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3686
3687
3688 # Test: Is there a JDK installed in default, well-known locations?
3689
3690
3691 # Check that a command-line tool in the Boot JDK is correct
3692 # $1 = name of variable to assign
3693 # $2 = name of binary
3694
3695
3696 ###############################################################################
3697 #
3698 # We need a Boot JDK to bootstrap the build.
3699 #
3700
3701
3702
3703
3704
3705 #
3706 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3707 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3708 #
3709 # This code is free software; you can redistribute it and/or modify it
3710 # under the terms of the GNU General Public License version 2 only, as
3711 # published by the Free Software Foundation. Oracle designates this
3712 # particular file as subject to the "Classpath" exception as provided
3713 # by Oracle in the LICENSE file that accompanied this code.
3714 #
3715 # This code is distributed in the hope that it will be useful, but WITHOUT
3716 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3717 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3718 # version 2 for more details (a copy is included in the LICENSE file that
3719 # accompanied this code).
3720 #
3721 # You should have received a copy of the GNU General Public License version
3722 # 2 along with this work; if not, write to the Free Software Foundation,
3723 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3724 #
3725 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3726 # or visit www.oracle.com if you need additional information or have any
3727 # questions.
3728 #
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749 #
3750 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3751 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3752 #
3753 # This code is free software; you can redistribute it and/or modify it
3754 # under the terms of the GNU General Public License version 2 only, as
3755 # published by the Free Software Foundation. Oracle designates this
3756 # particular file as subject to the "Classpath" exception as provided
3757 # by Oracle in the LICENSE file that accompanied this code.
3758 #
3759 # This code is distributed in the hope that it will be useful, but WITHOUT
3760 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3761 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3762 # version 2 for more details (a copy is included in the LICENSE file that
3763 # accompanied this code).
3764 #
3765 # You should have received a copy of the GNU General Public License version
3766 # 2 along with this work; if not, write to the Free Software Foundation,
3767 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3768 #
3769 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3770 # or visit www.oracle.com if you need additional information or have any
3771 # questions.
3772 #
3773
3774
3775
3776
3777
3778 # Documentation on common flags used for solstudio in HIGHEST.
3779 #
3780 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3781 # done with care, there are some assumptions below that need to
3782 # be understood about the use of pointers, and IEEE behavior.
3783 #
3784 # -fns: Use non-standard floating point mode (not IEEE 754)
3785 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3786 # -fsingle: Use single precision floating point with 'float'
3787 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3788 # (Source with excessing pointer casting and data access with mixed
3789 # pointer types are not recommended)
3790 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3791 # (If you expect perfect errno behavior, do not use this)
3792 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3793 # -xrestrict: Pointer parameters to functions do not overlap
3794 # (Similar to -xalias_level=basic usage, but less obvious sometimes.
3795 # If you pass in multiple pointers to the same data, do not use this)
3796 # -xlibmil: Inline some library routines
3797 # (If you expect perfect errno behavior, do not use this)
3798 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3799 # (If you expect perfect errno behavior, do not use this)
3800 # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3801
3802 # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3803 # Bug?
3804 #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3805 # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3806 # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3807 #fi
3808
3809
3810
3811
3812
3813 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3814 # [RUN-IF-FALSE])
3815 # ------------------------------------------------------------
3816 # Check that the c and c++ compilers support an argument
3817
3818
3819 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3820 # [RUN-IF-FALSE])
3821 # ------------------------------------------------------------
3822 # Check that the linker support an argument
3823
3824
3825
3826
3827 #
3828 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3829 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3830 #
3831 # This code is free software; you can redistribute it and/or modify it
3832 # under the terms of the GNU General Public License version 2 only, as
3833 # published by the Free Software Foundation. Oracle designates this
3834 # particular file as subject to the "Classpath" exception as provided
3835 # by Oracle in the LICENSE file that accompanied this code.
3836 #
3837 # This code is distributed in the hope that it will be useful, but WITHOUT
3838 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3839 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3840 # version 2 for more details (a copy is included in the LICENSE file that
3841 # accompanied this code).
3842 #
3843 # You should have received a copy of the GNU General Public License version
3844 # 2 along with this work; if not, write to the Free Software Foundation,
3845 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3846 #
3847 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3848 # or visit www.oracle.com if you need additional information or have any
3849 # questions.
3850 #
3851
3852
3853
3854
3855
3856 cygwin_help() {
3857 case $1 in
3858 unzip)
3859 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3860 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3861 ;;
3862 zip)
3863 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3864 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3865 ;;
3866 make)
3867 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3868 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3869 ;;
3870 freetype)
3871 HELP_MSG="
3872 The freetype library can now be build during the configure process.
3873 Download the freetype sources and unpack them into an arbitrary directory:
3874
3875 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3876 tar -xzf freetype-2.5.3.tar.gz
3877
3878 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3879 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3880 builds or into '<freetype_src>/lib32' for 32-bit builds.
3881 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3882 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3883 ;;
3884 esac
3885 }
3886
3887 msys_help() {
3888 PKGHANDLER_COMMAND=""
3889 }
3890
3891 apt_help() {
3892 case $1 in
3893 devkit)
3894 PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3895 openjdk)
3896 PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3897 alsa)
3898 PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3899 cups)
3900 PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3901 freetype)
3902 PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3903 pulse)
3904 PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3905 x11)
3906 PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3907 ccache)
3908 PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3909 esac
3910 }
3911
3912 yum_help() {
3913 case $1 in
3914 devkit)
3915 PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3916 openjdk)
3917 PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3918 alsa)
3919 PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3920 cups)
3921 PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3922 freetype)
3923 PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3924 pulse)
3925 PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3926 x11)
3927 PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3928 ccache)
3929 PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3930 esac
3931 }
3932
3933 port_help() {
3934 PKGHANDLER_COMMAND=""
3935 }
3936
3937 pkgutil_help() {
3938 PKGHANDLER_COMMAND=""
3939 }
3940
3941 pkgadd_help() {
3942 PKGHANDLER_COMMAND=""
3943 }
3944
3945 # This function will check if we're called from the "configure" wrapper while
3946 # printing --help. If so, we will print out additional information that can
3947 # only be extracted within the autoconf script, and then exit. This must be
3948 # called at the very beginning in configure.ac.
3949
3950
3951
3952
3953
3954
3955 #
3956 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3957 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3958 #
3959 # This code is free software; you can redistribute it and/or modify it
3960 # under the terms of the GNU General Public License version 2 only, as
3961 # published by the Free Software Foundation. Oracle designates this
3962 # particular file as subject to the "Classpath" exception as provided
3963 # by Oracle in the LICENSE file that accompanied this code.
3964 #
3965 # This code is distributed in the hope that it will be useful, but WITHOUT
3966 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3967 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3968 # version 2 for more details (a copy is included in the LICENSE file that
3969 # accompanied this code).
3970 #
3971 # You should have received a copy of the GNU General Public License version
3972 # 2 along with this work; if not, write to the Free Software Foundation,
3973 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3974 #
3975 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3976 # or visit www.oracle.com if you need additional information or have any
3977 # questions.
3978 #
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989 ###############################################################################
3990 #
3991 # Should we build only OpenJDK even if closed sources are present?
3992 #
3993
3994
3995
3996
3997 ###############################################################################
3998 #
3999 # Setup version numbers
4000 #
4001
4002
4003
4004
4005
4006
4007 ################################################################################
4008 #
4009 # Gcov coverage data for hotspot
4010 #
4011
4012
4013 #
4014 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
4015 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4016 #
4017 # This code is free software; you can redistribute it and/or modify it
4018 # under the terms of the GNU General Public License version 2 only, as
4019 # published by the Free Software Foundation. Oracle designates this
4020 # particular file as subject to the "Classpath" exception as provided
4021 # by Oracle in the LICENSE file that accompanied this code.
4022 #
4023 # This code is distributed in the hope that it will be useful, but WITHOUT
4024 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4025 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4026 # version 2 for more details (a copy is included in the LICENSE file that
4027 # accompanied this code).
4028 #
4029 # You should have received a copy of the GNU General Public License version
4030 # 2 along with this work; if not, write to the Free Software Foundation,
4031 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4032 #
4033 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4034 # or visit www.oracle.com if you need additional information or have any
4035 # questions.
4036 #
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058 #
4059 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4060 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4061 #
4062 # This code is free software; you can redistribute it and/or modify it
4063 # under the terms of the GNU General Public License version 2 only, as
4064 # published by the Free Software Foundation. Oracle designates this
4065 # particular file as subject to the "Classpath" exception as provided
4066 # by Oracle in the LICENSE file that accompanied this code.
4067 #
4068 # This code is distributed in the hope that it will be useful, but WITHOUT
4069 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4070 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4071 # version 2 for more details (a copy is included in the LICENSE file that
4072 # accompanied this code).
4073 #
4074 # You should have received a copy of the GNU General Public License version
4075 # 2 along with this work; if not, write to the Free Software Foundation,
4076 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4077 #
4078 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4079 # or visit www.oracle.com if you need additional information or have any
4080 # questions.
4081 #
4082
4083 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4084 # Converts autoconf style CPU name to OpenJDK style, into
4085 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4086
4087
4088 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4089 # Converts autoconf style OS name to OpenJDK style, into
4090 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4091
4092
4093 # Expects $host_os $host_cpu $build_os and $build_cpu
4094 # and $with_target_bits to have been setup!
4095 #
4096 # Translate the standard triplet(quadruplet) definition
4097 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4098 # OPENJDK_BUILD_OS, etc.
4099
4100
4101 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4102 # accordingly. Must be done after setting up build and target system, but before
4103 # doing anything else with these values.
4104
4105
4106 # Setup the legacy variables, for controlling the old makefiles.
4107 #
4108
4109
4110
4111
4112 #%%% Build and target systems %%%
4113
4114
4115
4116
4117 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4118 # Add -mX to various FLAGS variables.
4119
4120
4121
4122
4123
4124
4125 #
4126 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4127 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4128 #
4129 # This code is free software; you can redistribute it and/or modify it
4130 # under the terms of the GNU General Public License version 2 only, as
4131 # published by the Free Software Foundation. Oracle designates this
4132 # particular file as subject to the "Classpath" exception as provided
4133 # by Oracle in the LICENSE file that accompanied this code.
4134 #
4135 # This code is distributed in the hope that it will be useful, but WITHOUT
4136 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4137 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4138 # version 2 for more details (a copy is included in the LICENSE file that
4139 # accompanied this code).
4140 #
4141 # You should have received a copy of the GNU General Public License version
4142 # 2 along with this work; if not, write to the Free Software Foundation,
4143 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4144 #
4145 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4146 # or visit www.oracle.com if you need additional information or have any
4147 # questions.
4148 #
4149
4150
4151
4152
4153
4154
4155
4156
4157 #
4158 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4159 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4160 #
4161 # This code is free software; you can redistribute it and/or modify it
4162 # under the terms of the GNU General Public License version 2 only, as
4163 # published by the Free Software Foundation. Oracle designates this
4164 # particular file as subject to the "Classpath" exception as provided
4165 # by Oracle in the LICENSE file that accompanied this code.
4166 #
4167 # This code is distributed in the hope that it will be useful, but WITHOUT
4168 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4169 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4170 # version 2 for more details (a copy is included in the LICENSE file that
4171 # accompanied this code).
4172 #
4173 # You should have received a copy of the GNU General Public License version
4174 # 2 along with this work; if not, write to the Free Software Foundation,
4175 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4176 #
4177 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4178 # or visit www.oracle.com if you need additional information or have any
4179 # questions.
4180 #
4181
4182 ########################################################################
4183 # This file is responsible for detecting, verifying and setting up the
4184 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4185 # proper paths to the binaries, but it will not setup any flags.
4186 #
4187 # The binaries used is determined by the toolchain type, which is the family of
4188 # compilers and related tools that are used.
4189 ########################################################################
4190
4191
4192 # All valid toolchains, regardless of platform (used by help.m4)
4193 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4194
4195 # These toolchains are valid on different platforms
4196 VALID_TOOLCHAINS_linux="gcc clang"
4197 VALID_TOOLCHAINS_solaris="solstudio"
4198 VALID_TOOLCHAINS_macosx="gcc clang"
4199 VALID_TOOLCHAINS_aix="xlc"
4200 VALID_TOOLCHAINS_windows="microsoft"
4201
4202 # Toolchain descriptions
4203 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4204 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4205 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4206 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4207 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4208
4209 # Setup a number of variables describing how native output files are
4210 # named on this platform/toolchain.
4211
4212
4213 # Determine which toolchain type to use, and make sure it is valid for this
4214 # platform. Setup various information about the selected toolchain.
4215
4216
4217 # Before we start detecting the toolchain executables, we might need some
4218 # special setup, e.g. additional paths etc.
4219
4220
4221 # Restore path, etc
4222
4223
4224 # Check if a compiler is of the toolchain type we expect, and save the version
4225 # information from it. If the compiler does not match the expected type,
4226 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4227 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4228 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4229 #
4230 # $1 = compiler to test (CC or CXX)
4231 # $2 = human readable name of compiler (C or C++)
4232
4233
4234 # Try to locate the given C or C++ compiler in the path, or otherwise.
4235 #
4236 # $1 = compiler to test (CC or CXX)
4237 # $2 = human readable name of compiler (C or C++)
4238 # $3 = list of compiler names to search for
4239
4240
4241 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4242 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4243 # archiver (AR). Verify that the compilers are correct according to the
4244 # toolchain type.
4245
4246
4247 # Setup additional tools that is considered a part of the toolchain, but not the
4248 # core part. Many of these are highly platform-specific and do not exist,
4249 # and/or are not needed on all platforms.
4250
4251
4252 # Setup the build tools (i.e, the compiler and linker used to build programs
4253 # that should be run on the build platform, not the target platform, as a build
4254 # helper). Since the non-cross-compile case uses the normal, target compilers
4255 # for this, we can only do this after these have been setup.
4256
4257
4258 # Setup legacy variables that are still needed as alternative ways to refer to
4259 # parts of the toolchain.
4260
4261
4262 # Do some additional checks on the detected tools.
4263
4264
4265 # Setup the JTReg Regression Test Harness.
4266
4267
4268 #
4269 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4270 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4271 #
4272 # This code is free software; you can redistribute it and/or modify it
4273 # under the terms of the GNU General Public License version 2 only, as
4274 # published by the Free Software Foundation. Oracle designates this
4275 # particular file as subject to the "Classpath" exception as provided
4276 # by Oracle in the LICENSE file that accompanied this code.
4277 #
4278 # This code is distributed in the hope that it will be useful, but WITHOUT
4279 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4280 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4281 # version 2 for more details (a copy is included in the LICENSE file that
4282 # accompanied this code).
4283 #
4284 # You should have received a copy of the GNU General Public License version
4285 # 2 along with this work; if not, write to the Free Software Foundation,
4286 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4287 #
4288 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4289 # or visit www.oracle.com if you need additional information or have any
4290 # questions.
4291 #
4292
4293 ################################################################################
4294 # The order of these defines the priority by which we try to find them.
4295 VALID_VS_VERSIONS="2013 2012 2010"
4296
4297 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4298 VS_VERSION_INTERNAL_2010=100
4299 VS_MSVCR_2010=msvcr100.dll
4300 # We don't use msvcp on Visual Studio 2010
4301 #VS_MSVCP_2010=msvcp100.dll
4302 VS_ENVVAR_2010="VS100COMNTOOLS"
4303 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4304 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4305 VS_VS_PLATFORM_NAME_2010="v100"
4306 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4307
4308 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4309 VS_VERSION_INTERNAL_2012=110
4310 VS_MSVCR_2012=msvcr110.dll
4311 VS_MSVCP_2012=msvcp110.dll
4312 VS_ENVVAR_2012="VS110COMNTOOLS"
4313 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4314 VS_SDK_INSTALLDIR_2012=
4315 VS_VS_PLATFORM_NAME_2012="v110"
4316 VS_SDK_PLATFORM_NAME_2012=
4317
4318 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4319 VS_VERSION_INTERNAL_2013=120
4320 VS_MSVCR_2013=msvcr120.dll
4321 VS_MSVCP_2013=msvcp120.dll
4322 VS_ENVVAR_2013="VS120COMNTOOLS"
4323 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4324 VS_SDK_INSTALLDIR_2013=
4325 VS_VS_PLATFORM_NAME_2013="v120"
4326 VS_SDK_PLATFORM_NAME_2013=
4327
4328 ################################################################################
4329
4330
4331
4332 ################################################################################
4333
4334
4335
4336 ################################################################################
4337 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4338 # build environment and assigns it to VS_ENV_CMD
4339
4340
4341 ################################################################################
4342
4343
4344
4345 ################################################################################
4346 # Check if the VS env variables were setup prior to running configure.
4347 # If not, then find vcvarsall.bat and run it automatically, and integrate
4348 # the set env variables into the spec file.
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363 # This line needs to be here, verbatim, after all includes and the dummy hook
4364 # definitions. It is replaced with custom functionality when building
4365 # custom sources.
4366 #CUSTOM_AUTOCONF_INCLUDE
4367
4368 # Do not change or remove the following line, it is needed for consistency checks:
4369 DATE_WHEN_GENERATED=1432629750
4370
4371 ###############################################################################
4372 #
4373 # Initialization / Boot-strapping
4374 #
4375 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4376 # thus it jumps back and forth, each time gaining something needed later on.
4377 #
4378 ###############################################################################
4379
4380 # If we are requested to print additional help, do that and then exit.
4381 # This must be the very first call.
4382
4383 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4384 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4385 $PRINTF "Which are valid to use depends on the build platform.\n"
4386 for toolchain in $VALID_TOOLCHAINS_all; do
4387 # Use indirect variable referencing
4388 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4389 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4390 $PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4391 done
4392
4393 # And now exit directly
4394 exit 0
4395 fi
4396
4397
4398 # Basic initialization that must happen first of all in the normal process.
4399
4400 # Save the original command line. This is passed to us by the wrapper configure script.
4401
4402 # Save the path variable before it gets changed
4403 ORIGINAL_PATH="$PATH"
4404
4405 DATE_WHEN_CONFIGURED=`LANG=C date`
4406
4407 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4408 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4409 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4410 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4411
4412
4413 # Start with tools that do not need have cross compilation support
4414 # and can be expected to be found in the default PATH. These tools are
4415 # used by configure. Nor are these tools expected to be found in the
4416 # devkit from the builddeps server either, since they are
4417 # needed to download the devkit.
4418
4419 # First are all the simple required tools.
4420
4421
4422
4423 # Publish this variable in the help.
4424
4425
4426 if test "x$BASENAME" = x; then
4427 # The variable is not set by user, try to locate tool using the code snippet
4428 for ac_prog in basename
4429 do
4430 # Extract the first word of "$ac_prog", so it can be a program name with args.
4431 set dummy $ac_prog; ac_word=$2
4432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4433 $as_echo_n "checking for $ac_word... " >&6; }
4434 if ${ac_cv_path_BASENAME+:} false; then :
4435 $as_echo_n "(cached) " >&6
4436 else
4437 case $BASENAME in
4438 [\\/]* | ?:[\\/]*)
4439 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4440 ;;
4441 *)
4442 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4443 for as_dir in $PATH
4444 do
4445 IFS=$as_save_IFS
4446 test -z "$as_dir" && as_dir=.
4447 for ac_exec_ext in '' $ac_executable_extensions; do
4448 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4449 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4450 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4451 break 2
4452 fi
4453 done
4454 done
4455 IFS=$as_save_IFS
4456
4457 ;;
4458 esac
4459 fi
4460 BASENAME=$ac_cv_path_BASENAME
4461 if test -n "$BASENAME"; then
4462 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4463 $as_echo "$BASENAME" >&6; }
4464 else
4465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4466 $as_echo "no" >&6; }
4467 fi
4468
4469
4470 test -n "$BASENAME" && break
4471 done
4472
4473 else
4474 # The variable is set, but is it from the command line or the environment?
4475
4476 # Try to remove the string !BASENAME! from our list.
4477 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4478 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4479 # If it failed, the variable was not from the command line. Ignore it,
4480 # but warn the user (except for BASH, which is always set by the calling BASH).
4481 if test "xBASENAME" != xBASH; then
4482 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4483 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4484 fi
4485 # Try to locate tool using the code snippet
4486 for ac_prog in basename
4487 do
4488 # Extract the first word of "$ac_prog", so it can be a program name with args.
4489 set dummy $ac_prog; ac_word=$2
4490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4491 $as_echo_n "checking for $ac_word... " >&6; }
4492 if ${ac_cv_path_BASENAME+:} false; then :
4493 $as_echo_n "(cached) " >&6
4494 else
4495 case $BASENAME in
4496 [\\/]* | ?:[\\/]*)
4497 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4498 ;;
4499 *)
4500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4501 for as_dir in $PATH
4502 do
4503 IFS=$as_save_IFS
4504 test -z "$as_dir" && as_dir=.
4505 for ac_exec_ext in '' $ac_executable_extensions; do
4506 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4507 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4508 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4509 break 2
4510 fi
4511 done
4512 done
4513 IFS=$as_save_IFS
4514
4515 ;;
4516 esac
4517 fi
4518 BASENAME=$ac_cv_path_BASENAME
4519 if test -n "$BASENAME"; then
4520 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4521 $as_echo "$BASENAME" >&6; }
4522 else
4523 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4524 $as_echo "no" >&6; }
4525 fi
4526
4527
4528 test -n "$BASENAME" && break
4529 done
4530
4531 else
4532 # If it succeeded, then it was overridden by the user. We will use it
4533 # for the tool.
4534
4535 # First remove it from the list of overridden variables, so we can test
4536 # for unknown variables in the end.
4537 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4538
4539 # Check if the provided tool contains a complete path.
4540 tool_specified="$BASENAME"
4541 tool_basename="${tool_specified##*/}"
4542 if test "x$tool_basename" = "x$tool_specified"; then
4543 # A command without a complete path is provided, search $PATH.
4544 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4545 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4546 # Extract the first word of "$tool_basename", so it can be a program name with args.
4547 set dummy $tool_basename; ac_word=$2
4548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4549 $as_echo_n "checking for $ac_word... " >&6; }
4550 if ${ac_cv_path_BASENAME+:} false; then :
4551 $as_echo_n "(cached) " >&6
4552 else
4553 case $BASENAME in
4554 [\\/]* | ?:[\\/]*)
4555 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4556 ;;
4557 *)
4558 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4559 for as_dir in $PATH
4560 do
4561 IFS=$as_save_IFS
4562 test -z "$as_dir" && as_dir=.
4563 for ac_exec_ext in '' $ac_executable_extensions; do
4564 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4565 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4566 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4567 break 2
4568 fi
4569 done
4570 done
4571 IFS=$as_save_IFS
4572
4573 ;;
4574 esac
4575 fi
4576 BASENAME=$ac_cv_path_BASENAME
4577 if test -n "$BASENAME"; then
4578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4579 $as_echo "$BASENAME" >&6; }
4580 else
4581 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4582 $as_echo "no" >&6; }
4583 fi
4584
4585
4586 if test "x$BASENAME" = x; then
4587 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4588 fi
4589 else
4590 # Otherwise we believe it is a complete path. Use it as it is.
4591 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4592 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4594 $as_echo_n "checking for BASENAME... " >&6; }
4595 if test ! -x "$tool_specified"; then
4596 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4597 $as_echo "not found" >&6; }
4598 as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4599 fi
4600 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4601 $as_echo "$tool_specified" >&6; }
4602 fi
4603 fi
4604 fi
4605
4606
4607
4608 if test "x$BASENAME" = x; then
4609 as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4610 fi
4611
4612
4613
4614
4615
4616 # Publish this variable in the help.
4617
4618
4619 if test "x$BASH" = x; then
4620 # The variable is not set by user, try to locate tool using the code snippet
4621 for ac_prog in bash
4622 do
4623 # Extract the first word of "$ac_prog", so it can be a program name with args.
4624 set dummy $ac_prog; ac_word=$2
4625 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4626 $as_echo_n "checking for $ac_word... " >&6; }
4627 if ${ac_cv_path_BASH+:} false; then :
4628 $as_echo_n "(cached) " >&6
4629 else
4630 case $BASH in
4631 [\\/]* | ?:[\\/]*)
4632 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4633 ;;
4634 *)
4635 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4636 for as_dir in $PATH
4637 do
4638 IFS=$as_save_IFS
4639 test -z "$as_dir" && as_dir=.
4640 for ac_exec_ext in '' $ac_executable_extensions; do
4641 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4642 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4643 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4644 break 2
4645 fi
4646 done
4647 done
4648 IFS=$as_save_IFS
4649
4650 ;;
4651 esac
4652 fi
4653 BASH=$ac_cv_path_BASH
4654 if test -n "$BASH"; then
4655 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4656 $as_echo "$BASH" >&6; }
4657 else
4658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4659 $as_echo "no" >&6; }
4660 fi
4661
4662
4663 test -n "$BASH" && break
4664 done
4665
4666 else
4667 # The variable is set, but is it from the command line or the environment?
4668
4669 # Try to remove the string !BASH! from our list.
4670 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4671 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4672 # If it failed, the variable was not from the command line. Ignore it,
4673 # but warn the user (except for BASH, which is always set by the calling BASH).
4674 if test "xBASH" != xBASH; then
4675 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4676 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4677 fi
4678 # Try to locate tool using the code snippet
4679 for ac_prog in bash
4680 do
4681 # Extract the first word of "$ac_prog", so it can be a program name with args.
4682 set dummy $ac_prog; ac_word=$2
4683 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4684 $as_echo_n "checking for $ac_word... " >&6; }
4685 if ${ac_cv_path_BASH+:} false; then :
4686 $as_echo_n "(cached) " >&6
4687 else
4688 case $BASH in
4689 [\\/]* | ?:[\\/]*)
4690 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4691 ;;
4692 *)
4693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4694 for as_dir in $PATH
4695 do
4696 IFS=$as_save_IFS
4697 test -z "$as_dir" && as_dir=.
4698 for ac_exec_ext in '' $ac_executable_extensions; do
4699 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4700 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4701 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4702 break 2
4703 fi
4704 done
4705 done
4706 IFS=$as_save_IFS
4707
4708 ;;
4709 esac
4710 fi
4711 BASH=$ac_cv_path_BASH
4712 if test -n "$BASH"; then
4713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4714 $as_echo "$BASH" >&6; }
4715 else
4716 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4717 $as_echo "no" >&6; }
4718 fi
4719
4720
4721 test -n "$BASH" && break
4722 done
4723
4724 else
4725 # If it succeeded, then it was overridden by the user. We will use it
4726 # for the tool.
4727
4728 # First remove it from the list of overridden variables, so we can test
4729 # for unknown variables in the end.
4730 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4731
4732 # Check if the provided tool contains a complete path.
4733 tool_specified="$BASH"
4734 tool_basename="${tool_specified##*/}"
4735 if test "x$tool_basename" = "x$tool_specified"; then
4736 # A command without a complete path is provided, search $PATH.
4737 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4738 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4739 # Extract the first word of "$tool_basename", so it can be a program name with args.
4740 set dummy $tool_basename; ac_word=$2
4741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4742 $as_echo_n "checking for $ac_word... " >&6; }
4743 if ${ac_cv_path_BASH+:} false; then :
4744 $as_echo_n "(cached) " >&6
4745 else
4746 case $BASH in
4747 [\\/]* | ?:[\\/]*)
4748 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4749 ;;
4750 *)
4751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4752 for as_dir in $PATH
4753 do
4754 IFS=$as_save_IFS
4755 test -z "$as_dir" && as_dir=.
4756 for ac_exec_ext in '' $ac_executable_extensions; do
4757 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4758 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4759 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4760 break 2
4761 fi
4762 done
4763 done
4764 IFS=$as_save_IFS
4765
4766 ;;
4767 esac
4768 fi
4769 BASH=$ac_cv_path_BASH
4770 if test -n "$BASH"; then
4771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4772 $as_echo "$BASH" >&6; }
4773 else
4774 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4775 $as_echo "no" >&6; }
4776 fi
4777
4778
4779 if test "x$BASH" = x; then
4780 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4781 fi
4782 else
4783 # Otherwise we believe it is a complete path. Use it as it is.
4784 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4785 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4786 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4787 $as_echo_n "checking for BASH... " >&6; }
4788 if test ! -x "$tool_specified"; then
4789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4790 $as_echo "not found" >&6; }
4791 as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4792 fi
4793 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4794 $as_echo "$tool_specified" >&6; }
4795 fi
4796 fi
4797 fi
4798
4799
4800
4801 if test "x$BASH" = x; then
4802 as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4803 fi
4804
4805
4806
4807
4808
4809 # Publish this variable in the help.
4810
4811
4812 if test "x$CAT" = x; then
4813 # The variable is not set by user, try to locate tool using the code snippet
4814 for ac_prog in cat
4815 do
4816 # Extract the first word of "$ac_prog", so it can be a program name with args.
4817 set dummy $ac_prog; ac_word=$2
4818 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4819 $as_echo_n "checking for $ac_word... " >&6; }
4820 if ${ac_cv_path_CAT+:} false; then :
4821 $as_echo_n "(cached) " >&6
4822 else
4823 case $CAT in
4824 [\\/]* | ?:[\\/]*)
4825 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4826 ;;
4827 *)
4828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4829 for as_dir in $PATH
4830 do
4831 IFS=$as_save_IFS
4832 test -z "$as_dir" && as_dir=.
4833 for ac_exec_ext in '' $ac_executable_extensions; do
4834 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4835 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4836 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4837 break 2
4838 fi
4839 done
4840 done
4841 IFS=$as_save_IFS
4842
4843 ;;
4844 esac
4845 fi
4846 CAT=$ac_cv_path_CAT
4847 if test -n "$CAT"; then
4848 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4849 $as_echo "$CAT" >&6; }
4850 else
4851 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4852 $as_echo "no" >&6; }
4853 fi
4854
4855
4856 test -n "$CAT" && break
4857 done
4858
4859 else
4860 # The variable is set, but is it from the command line or the environment?
4861
4862 # Try to remove the string !CAT! from our list.
4863 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4864 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4865 # If it failed, the variable was not from the command line. Ignore it,
4866 # but warn the user (except for BASH, which is always set by the calling BASH).
4867 if test "xCAT" != xBASH; then
4868 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4869 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4870 fi
4871 # Try to locate tool using the code snippet
4872 for ac_prog in cat
4873 do
4874 # Extract the first word of "$ac_prog", so it can be a program name with args.
4875 set dummy $ac_prog; ac_word=$2
4876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4877 $as_echo_n "checking for $ac_word... " >&6; }
4878 if ${ac_cv_path_CAT+:} false; then :
4879 $as_echo_n "(cached) " >&6
4880 else
4881 case $CAT in
4882 [\\/]* | ?:[\\/]*)
4883 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4884 ;;
4885 *)
4886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4887 for as_dir in $PATH
4888 do
4889 IFS=$as_save_IFS
4890 test -z "$as_dir" && as_dir=.
4891 for ac_exec_ext in '' $ac_executable_extensions; do
4892 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4893 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4894 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4895 break 2
4896 fi
4897 done
4898 done
4899 IFS=$as_save_IFS
4900
4901 ;;
4902 esac
4903 fi
4904 CAT=$ac_cv_path_CAT
4905 if test -n "$CAT"; then
4906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4907 $as_echo "$CAT" >&6; }
4908 else
4909 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4910 $as_echo "no" >&6; }
4911 fi
4912
4913
4914 test -n "$CAT" && break
4915 done
4916
4917 else
4918 # If it succeeded, then it was overridden by the user. We will use it
4919 # for the tool.
4920
4921 # First remove it from the list of overridden variables, so we can test
4922 # for unknown variables in the end.
4923 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4924
4925 # Check if the provided tool contains a complete path.
4926 tool_specified="$CAT"
4927 tool_basename="${tool_specified##*/}"
4928 if test "x$tool_basename" = "x$tool_specified"; then
4929 # A command without a complete path is provided, search $PATH.
4930 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4931 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4932 # Extract the first word of "$tool_basename", so it can be a program name with args.
4933 set dummy $tool_basename; ac_word=$2
4934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4935 $as_echo_n "checking for $ac_word... " >&6; }
4936 if ${ac_cv_path_CAT+:} false; then :
4937 $as_echo_n "(cached) " >&6
4938 else
4939 case $CAT in
4940 [\\/]* | ?:[\\/]*)
4941 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4942 ;;
4943 *)
4944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4945 for as_dir in $PATH
4946 do
4947 IFS=$as_save_IFS
4948 test -z "$as_dir" && as_dir=.
4949 for ac_exec_ext in '' $ac_executable_extensions; do
4950 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4951 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4952 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4953 break 2
4954 fi
4955 done
4956 done
4957 IFS=$as_save_IFS
4958
4959 ;;
4960 esac
4961 fi
4962 CAT=$ac_cv_path_CAT
4963 if test -n "$CAT"; then
4964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4965 $as_echo "$CAT" >&6; }
4966 else
4967 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4968 $as_echo "no" >&6; }
4969 fi
4970
4971
4972 if test "x$CAT" = x; then
4973 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4974 fi
4975 else
4976 # Otherwise we believe it is a complete path. Use it as it is.
4977 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4978 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4979 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4980 $as_echo_n "checking for CAT... " >&6; }
4981 if test ! -x "$tool_specified"; then
4982 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4983 $as_echo "not found" >&6; }
4984 as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4985 fi
4986 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4987 $as_echo "$tool_specified" >&6; }
4988 fi
4989 fi
4990 fi
4991
4992
4993
4994 if test "x$CAT" = x; then
4995 as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4996 fi
4997
4998
4999
5000
5001
5002 # Publish this variable in the help.
5003
5004
5005 if test "x$CHMOD" = x; then
5006 # The variable is not set by user, try to locate tool using the code snippet
5007 for ac_prog in chmod
5008 do
5009 # Extract the first word of "$ac_prog", so it can be a program name with args.
5010 set dummy $ac_prog; ac_word=$2
5011 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5012 $as_echo_n "checking for $ac_word... " >&6; }
5013 if ${ac_cv_path_CHMOD+:} false; then :
5014 $as_echo_n "(cached) " >&6
5015 else
5016 case $CHMOD in
5017 [\\/]* | ?:[\\/]*)
5018 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5019 ;;
5020 *)
5021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5022 for as_dir in $PATH
5023 do
5024 IFS=$as_save_IFS
5025 test -z "$as_dir" && as_dir=.
5026 for ac_exec_ext in '' $ac_executable_extensions; do
5027 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5028 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5029 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5030 break 2
5031 fi
5032 done
5033 done
5034 IFS=$as_save_IFS
5035
5036 ;;
5037 esac
5038 fi
5039 CHMOD=$ac_cv_path_CHMOD
5040 if test -n "$CHMOD"; then
5041 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5042 $as_echo "$CHMOD" >&6; }
5043 else
5044 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5045 $as_echo "no" >&6; }
5046 fi
5047
5048
5049 test -n "$CHMOD" && break
5050 done
5051
5052 else
5053 # The variable is set, but is it from the command line or the environment?
5054
5055 # Try to remove the string !CHMOD! from our list.
5056 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5057 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5058 # If it failed, the variable was not from the command line. Ignore it,
5059 # but warn the user (except for BASH, which is always set by the calling BASH).
5060 if test "xCHMOD" != xBASH; then
5061 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5062 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5063 fi
5064 # Try to locate tool using the code snippet
5065 for ac_prog in chmod
5066 do
5067 # Extract the first word of "$ac_prog", so it can be a program name with args.
5068 set dummy $ac_prog; ac_word=$2
5069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5070 $as_echo_n "checking for $ac_word... " >&6; }
5071 if ${ac_cv_path_CHMOD+:} false; then :
5072 $as_echo_n "(cached) " >&6
5073 else
5074 case $CHMOD in
5075 [\\/]* | ?:[\\/]*)
5076 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5077 ;;
5078 *)
5079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5080 for as_dir in $PATH
5081 do
5082 IFS=$as_save_IFS
5083 test -z "$as_dir" && as_dir=.
5084 for ac_exec_ext in '' $ac_executable_extensions; do
5085 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5086 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5087 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5088 break 2
5089 fi
5090 done
5091 done
5092 IFS=$as_save_IFS
5093
5094 ;;
5095 esac
5096 fi
5097 CHMOD=$ac_cv_path_CHMOD
5098 if test -n "$CHMOD"; then
5099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5100 $as_echo "$CHMOD" >&6; }
5101 else
5102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5103 $as_echo "no" >&6; }
5104 fi
5105
5106
5107 test -n "$CHMOD" && break
5108 done
5109
5110 else
5111 # If it succeeded, then it was overridden by the user. We will use it
5112 # for the tool.
5113
5114 # First remove it from the list of overridden variables, so we can test
5115 # for unknown variables in the end.
5116 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5117
5118 # Check if the provided tool contains a complete path.
5119 tool_specified="$CHMOD"
5120 tool_basename="${tool_specified##*/}"
5121 if test "x$tool_basename" = "x$tool_specified"; then
5122 # A command without a complete path is provided, search $PATH.
5123 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5124 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5125 # Extract the first word of "$tool_basename", so it can be a program name with args.
5126 set dummy $tool_basename; ac_word=$2
5127 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5128 $as_echo_n "checking for $ac_word... " >&6; }
5129 if ${ac_cv_path_CHMOD+:} false; then :
5130 $as_echo_n "(cached) " >&6
5131 else
5132 case $CHMOD in
5133 [\\/]* | ?:[\\/]*)
5134 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5135 ;;
5136 *)
5137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5138 for as_dir in $PATH
5139 do
5140 IFS=$as_save_IFS
5141 test -z "$as_dir" && as_dir=.
5142 for ac_exec_ext in '' $ac_executable_extensions; do
5143 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5144 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5145 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5146 break 2
5147 fi
5148 done
5149 done
5150 IFS=$as_save_IFS
5151
5152 ;;
5153 esac
5154 fi
5155 CHMOD=$ac_cv_path_CHMOD
5156 if test -n "$CHMOD"; then
5157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5158 $as_echo "$CHMOD" >&6; }
5159 else
5160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5161 $as_echo "no" >&6; }
5162 fi
5163
5164
5165 if test "x$CHMOD" = x; then
5166 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5167 fi
5168 else
5169 # Otherwise we believe it is a complete path. Use it as it is.
5170 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5171 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5172 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5173 $as_echo_n "checking for CHMOD... " >&6; }
5174 if test ! -x "$tool_specified"; then
5175 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5176 $as_echo "not found" >&6; }
5177 as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5178 fi
5179 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5180 $as_echo "$tool_specified" >&6; }
5181 fi
5182 fi
5183 fi
5184
5185
5186
5187 if test "x$CHMOD" = x; then
5188 as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5189 fi
5190
5191
5192
5193
5194
5195 # Publish this variable in the help.
5196
5197
5198 if test "x$CMP" = x; then
5199 # The variable is not set by user, try to locate tool using the code snippet
5200 for ac_prog in cmp
5201 do
5202 # Extract the first word of "$ac_prog", so it can be a program name with args.
5203 set dummy $ac_prog; ac_word=$2
5204 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5205 $as_echo_n "checking for $ac_word... " >&6; }
5206 if ${ac_cv_path_CMP+:} false; then :
5207 $as_echo_n "(cached) " >&6
5208 else
5209 case $CMP in
5210 [\\/]* | ?:[\\/]*)
5211 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5212 ;;
5213 *)
5214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5215 for as_dir in $PATH
5216 do
5217 IFS=$as_save_IFS
5218 test -z "$as_dir" && as_dir=.
5219 for ac_exec_ext in '' $ac_executable_extensions; do
5220 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5221 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5222 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5223 break 2
5224 fi
5225 done
5226 done
5227 IFS=$as_save_IFS
5228
5229 ;;
5230 esac
5231 fi
5232 CMP=$ac_cv_path_CMP
5233 if test -n "$CMP"; then
5234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5235 $as_echo "$CMP" >&6; }
5236 else
5237 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5238 $as_echo "no" >&6; }
5239 fi
5240
5241
5242 test -n "$CMP" && break
5243 done
5244
5245 else
5246 # The variable is set, but is it from the command line or the environment?
5247
5248 # Try to remove the string !CMP! from our list.
5249 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5250 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5251 # If it failed, the variable was not from the command line. Ignore it,
5252 # but warn the user (except for BASH, which is always set by the calling BASH).
5253 if test "xCMP" != xBASH; then
5254 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5255 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5256 fi
5257 # Try to locate tool using the code snippet
5258 for ac_prog in cmp
5259 do
5260 # Extract the first word of "$ac_prog", so it can be a program name with args.
5261 set dummy $ac_prog; ac_word=$2
5262 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5263 $as_echo_n "checking for $ac_word... " >&6; }
5264 if ${ac_cv_path_CMP+:} false; then :
5265 $as_echo_n "(cached) " >&6
5266 else
5267 case $CMP in
5268 [\\/]* | ?:[\\/]*)
5269 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5270 ;;
5271 *)
5272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5273 for as_dir in $PATH
5274 do
5275 IFS=$as_save_IFS
5276 test -z "$as_dir" && as_dir=.
5277 for ac_exec_ext in '' $ac_executable_extensions; do
5278 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5279 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5280 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5281 break 2
5282 fi
5283 done
5284 done
5285 IFS=$as_save_IFS
5286
5287 ;;
5288 esac
5289 fi
5290 CMP=$ac_cv_path_CMP
5291 if test -n "$CMP"; then
5292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5293 $as_echo "$CMP" >&6; }
5294 else
5295 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5296 $as_echo "no" >&6; }
5297 fi
5298
5299
5300 test -n "$CMP" && break
5301 done
5302
5303 else
5304 # If it succeeded, then it was overridden by the user. We will use it
5305 # for the tool.
5306
5307 # First remove it from the list of overridden variables, so we can test
5308 # for unknown variables in the end.
5309 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5310
5311 # Check if the provided tool contains a complete path.
5312 tool_specified="$CMP"
5313 tool_basename="${tool_specified##*/}"
5314 if test "x$tool_basename" = "x$tool_specified"; then
5315 # A command without a complete path is provided, search $PATH.
5316 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5317 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5318 # Extract the first word of "$tool_basename", so it can be a program name with args.
5319 set dummy $tool_basename; ac_word=$2
5320 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5321 $as_echo_n "checking for $ac_word... " >&6; }
5322 if ${ac_cv_path_CMP+:} false; then :
5323 $as_echo_n "(cached) " >&6
5324 else
5325 case $CMP in
5326 [\\/]* | ?:[\\/]*)
5327 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5328 ;;
5329 *)
5330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5331 for as_dir in $PATH
5332 do
5333 IFS=$as_save_IFS
5334 test -z "$as_dir" && as_dir=.
5335 for ac_exec_ext in '' $ac_executable_extensions; do
5336 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5337 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5338 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5339 break 2
5340 fi
5341 done
5342 done
5343 IFS=$as_save_IFS
5344
5345 ;;
5346 esac
5347 fi
5348 CMP=$ac_cv_path_CMP
5349 if test -n "$CMP"; then
5350 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5351 $as_echo "$CMP" >&6; }
5352 else
5353 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5354 $as_echo "no" >&6; }
5355 fi
5356
5357
5358 if test "x$CMP" = x; then
5359 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5360 fi
5361 else
5362 # Otherwise we believe it is a complete path. Use it as it is.
5363 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5364 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5366 $as_echo_n "checking for CMP... " >&6; }
5367 if test ! -x "$tool_specified"; then
5368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5369 $as_echo "not found" >&6; }
5370 as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5371 fi
5372 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5373 $as_echo "$tool_specified" >&6; }
5374 fi
5375 fi
5376 fi
5377
5378
5379
5380 if test "x$CMP" = x; then
5381 as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5382 fi
5383
5384
5385
5386
5387
5388 # Publish this variable in the help.
5389
5390
5391 if test "x$COMM" = x; then
5392 # The variable is not set by user, try to locate tool using the code snippet
5393 for ac_prog in comm
5394 do
5395 # Extract the first word of "$ac_prog", so it can be a program name with args.
5396 set dummy $ac_prog; ac_word=$2
5397 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5398 $as_echo_n "checking for $ac_word... " >&6; }
5399 if ${ac_cv_path_COMM+:} false; then :
5400 $as_echo_n "(cached) " >&6
5401 else
5402 case $COMM in
5403 [\\/]* | ?:[\\/]*)
5404 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5405 ;;
5406 *)
5407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5408 for as_dir in $PATH
5409 do
5410 IFS=$as_save_IFS
5411 test -z "$as_dir" && as_dir=.
5412 for ac_exec_ext in '' $ac_executable_extensions; do
5413 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5414 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5415 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5416 break 2
5417 fi
5418 done
5419 done
5420 IFS=$as_save_IFS
5421
5422 ;;
5423 esac
5424 fi
5425 COMM=$ac_cv_path_COMM
5426 if test -n "$COMM"; then
5427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5428 $as_echo "$COMM" >&6; }
5429 else
5430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5431 $as_echo "no" >&6; }
5432 fi
5433
5434
5435 test -n "$COMM" && break
5436 done
5437
5438 else
5439 # The variable is set, but is it from the command line or the environment?
5440
5441 # Try to remove the string !COMM! from our list.
5442 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5443 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5444 # If it failed, the variable was not from the command line. Ignore it,
5445 # but warn the user (except for BASH, which is always set by the calling BASH).
5446 if test "xCOMM" != xBASH; then
5447 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5448 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5449 fi
5450 # Try to locate tool using the code snippet
5451 for ac_prog in comm
5452 do
5453 # Extract the first word of "$ac_prog", so it can be a program name with args.
5454 set dummy $ac_prog; ac_word=$2
5455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5456 $as_echo_n "checking for $ac_word... " >&6; }
5457 if ${ac_cv_path_COMM+:} false; then :
5458 $as_echo_n "(cached) " >&6
5459 else
5460 case $COMM in
5461 [\\/]* | ?:[\\/]*)
5462 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5463 ;;
5464 *)
5465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5466 for as_dir in $PATH
5467 do
5468 IFS=$as_save_IFS
5469 test -z "$as_dir" && as_dir=.
5470 for ac_exec_ext in '' $ac_executable_extensions; do
5471 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5472 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5473 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5474 break 2
5475 fi
5476 done
5477 done
5478 IFS=$as_save_IFS
5479
5480 ;;
5481 esac
5482 fi
5483 COMM=$ac_cv_path_COMM
5484 if test -n "$COMM"; then
5485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5486 $as_echo "$COMM" >&6; }
5487 else
5488 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5489 $as_echo "no" >&6; }
5490 fi
5491
5492
5493 test -n "$COMM" && break
5494 done
5495
5496 else
5497 # If it succeeded, then it was overridden by the user. We will use it
5498 # for the tool.
5499
5500 # First remove it from the list of overridden variables, so we can test
5501 # for unknown variables in the end.
5502 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5503
5504 # Check if the provided tool contains a complete path.
5505 tool_specified="$COMM"
5506 tool_basename="${tool_specified##*/}"
5507 if test "x$tool_basename" = "x$tool_specified"; then
5508 # A command without a complete path is provided, search $PATH.
5509 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5510 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5511 # Extract the first word of "$tool_basename", so it can be a program name with args.
5512 set dummy $tool_basename; ac_word=$2
5513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5514 $as_echo_n "checking for $ac_word... " >&6; }
5515 if ${ac_cv_path_COMM+:} false; then :
5516 $as_echo_n "(cached) " >&6
5517 else
5518 case $COMM in
5519 [\\/]* | ?:[\\/]*)
5520 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5521 ;;
5522 *)
5523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5524 for as_dir in $PATH
5525 do
5526 IFS=$as_save_IFS
5527 test -z "$as_dir" && as_dir=.
5528 for ac_exec_ext in '' $ac_executable_extensions; do
5529 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5530 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5531 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5532 break 2
5533 fi
5534 done
5535 done
5536 IFS=$as_save_IFS
5537
5538 ;;
5539 esac
5540 fi
5541 COMM=$ac_cv_path_COMM
5542 if test -n "$COMM"; then
5543 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5544 $as_echo "$COMM" >&6; }
5545 else
5546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5547 $as_echo "no" >&6; }
5548 fi
5549
5550
5551 if test "x$COMM" = x; then
5552 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5553 fi
5554 else
5555 # Otherwise we believe it is a complete path. Use it as it is.
5556 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5557 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5558 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5559 $as_echo_n "checking for COMM... " >&6; }
5560 if test ! -x "$tool_specified"; then
5561 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5562 $as_echo "not found" >&6; }
5563 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5564 fi
5565 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5566 $as_echo "$tool_specified" >&6; }
5567 fi
5568 fi
5569 fi
5570
5571
5572
5573 if test "x$COMM" = x; then
5574 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5575 fi
5576
5577
5578
5579
5580
5581 # Publish this variable in the help.
5582
5583
5584 if test "x$CP" = x; then
5585 # The variable is not set by user, try to locate tool using the code snippet
5586 for ac_prog in cp
5587 do
5588 # Extract the first word of "$ac_prog", so it can be a program name with args.
5589 set dummy $ac_prog; ac_word=$2
5590 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5591 $as_echo_n "checking for $ac_word... " >&6; }
5592 if ${ac_cv_path_CP+:} false; then :
5593 $as_echo_n "(cached) " >&6
5594 else
5595 case $CP in
5596 [\\/]* | ?:[\\/]*)
5597 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5598 ;;
5599 *)
5600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5601 for as_dir in $PATH
5602 do
5603 IFS=$as_save_IFS
5604 test -z "$as_dir" && as_dir=.
5605 for ac_exec_ext in '' $ac_executable_extensions; do
5606 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5607 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5608 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5609 break 2
5610 fi
5611 done
5612 done
5613 IFS=$as_save_IFS
5614
5615 ;;
5616 esac
5617 fi
5618 CP=$ac_cv_path_CP
5619 if test -n "$CP"; then
5620 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5621 $as_echo "$CP" >&6; }
5622 else
5623 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5624 $as_echo "no" >&6; }
5625 fi
5626
5627
5628 test -n "$CP" && break
5629 done
5630
5631 else
5632 # The variable is set, but is it from the command line or the environment?
5633
5634 # Try to remove the string !CP! from our list.
5635 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5636 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5637 # If it failed, the variable was not from the command line. Ignore it,
5638 # but warn the user (except for BASH, which is always set by the calling BASH).
5639 if test "xCP" != xBASH; then
5640 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5641 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5642 fi
5643 # Try to locate tool using the code snippet
5644 for ac_prog in cp
5645 do
5646 # Extract the first word of "$ac_prog", so it can be a program name with args.
5647 set dummy $ac_prog; ac_word=$2
5648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5649 $as_echo_n "checking for $ac_word... " >&6; }
5650 if ${ac_cv_path_CP+:} false; then :
5651 $as_echo_n "(cached) " >&6
5652 else
5653 case $CP in
5654 [\\/]* | ?:[\\/]*)
5655 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5656 ;;
5657 *)
5658 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5659 for as_dir in $PATH
5660 do
5661 IFS=$as_save_IFS
5662 test -z "$as_dir" && as_dir=.
5663 for ac_exec_ext in '' $ac_executable_extensions; do
5664 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5665 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5666 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5667 break 2
5668 fi
5669 done
5670 done
5671 IFS=$as_save_IFS
5672
5673 ;;
5674 esac
5675 fi
5676 CP=$ac_cv_path_CP
5677 if test -n "$CP"; then
5678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5679 $as_echo "$CP" >&6; }
5680 else
5681 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5682 $as_echo "no" >&6; }
5683 fi
5684
5685
5686 test -n "$CP" && break
5687 done
5688
5689 else
5690 # If it succeeded, then it was overridden by the user. We will use it
5691 # for the tool.
5692
5693 # First remove it from the list of overridden variables, so we can test
5694 # for unknown variables in the end.
5695 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5696
5697 # Check if the provided tool contains a complete path.
5698 tool_specified="$CP"
5699 tool_basename="${tool_specified##*/}"
5700 if test "x$tool_basename" = "x$tool_specified"; then
5701 # A command without a complete path is provided, search $PATH.
5702 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5703 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5704 # Extract the first word of "$tool_basename", so it can be a program name with args.
5705 set dummy $tool_basename; ac_word=$2
5706 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5707 $as_echo_n "checking for $ac_word... " >&6; }
5708 if ${ac_cv_path_CP+:} false; then :
5709 $as_echo_n "(cached) " >&6
5710 else
5711 case $CP in
5712 [\\/]* | ?:[\\/]*)
5713 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5714 ;;
5715 *)
5716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5717 for as_dir in $PATH
5718 do
5719 IFS=$as_save_IFS
5720 test -z "$as_dir" && as_dir=.
5721 for ac_exec_ext in '' $ac_executable_extensions; do
5722 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5723 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5724 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5725 break 2
5726 fi
5727 done
5728 done
5729 IFS=$as_save_IFS
5730
5731 ;;
5732 esac
5733 fi
5734 CP=$ac_cv_path_CP
5735 if test -n "$CP"; then
5736 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5737 $as_echo "$CP" >&6; }
5738 else
5739 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5740 $as_echo "no" >&6; }
5741 fi
5742
5743
5744 if test "x$CP" = x; then
5745 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5746 fi
5747 else
5748 # Otherwise we believe it is a complete path. Use it as it is.
5749 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5750 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5752 $as_echo_n "checking for CP... " >&6; }
5753 if test ! -x "$tool_specified"; then
5754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5755 $as_echo "not found" >&6; }
5756 as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5757 fi
5758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5759 $as_echo "$tool_specified" >&6; }
5760 fi
5761 fi
5762 fi
5763
5764
5765
5766 if test "x$CP" = x; then
5767 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5768 fi
5769
5770
5771
5772
5773
5774 # Publish this variable in the help.
5775
5776
5777 if test "x$CUT" = x; then
5778 # The variable is not set by user, try to locate tool using the code snippet
5779 for ac_prog in cut
5780 do
5781 # Extract the first word of "$ac_prog", so it can be a program name with args.
5782 set dummy $ac_prog; ac_word=$2
5783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5784 $as_echo_n "checking for $ac_word... " >&6; }
5785 if ${ac_cv_path_CUT+:} false; then :
5786 $as_echo_n "(cached) " >&6
5787 else
5788 case $CUT in
5789 [\\/]* | ?:[\\/]*)
5790 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5791 ;;
5792 *)
5793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5794 for as_dir in $PATH
5795 do
5796 IFS=$as_save_IFS
5797 test -z "$as_dir" && as_dir=.
5798 for ac_exec_ext in '' $ac_executable_extensions; do
5799 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5800 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5801 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5802 break 2
5803 fi
5804 done
5805 done
5806 IFS=$as_save_IFS
5807
5808 ;;
5809 esac
5810 fi
5811 CUT=$ac_cv_path_CUT
5812 if test -n "$CUT"; then
5813 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5814 $as_echo "$CUT" >&6; }
5815 else
5816 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5817 $as_echo "no" >&6; }
5818 fi
5819
5820
5821 test -n "$CUT" && break
5822 done
5823
5824 else
5825 # The variable is set, but is it from the command line or the environment?
5826
5827 # Try to remove the string !CUT! from our list.
5828 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5829 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5830 # If it failed, the variable was not from the command line. Ignore it,
5831 # but warn the user (except for BASH, which is always set by the calling BASH).
5832 if test "xCUT" != xBASH; then
5833 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5834 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5835 fi
5836 # Try to locate tool using the code snippet
5837 for ac_prog in cut
5838 do
5839 # Extract the first word of "$ac_prog", so it can be a program name with args.
5840 set dummy $ac_prog; ac_word=$2
5841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5842 $as_echo_n "checking for $ac_word... " >&6; }
5843 if ${ac_cv_path_CUT+:} false; then :
5844 $as_echo_n "(cached) " >&6
5845 else
5846 case $CUT in
5847 [\\/]* | ?:[\\/]*)
5848 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5849 ;;
5850 *)
5851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5852 for as_dir in $PATH
5853 do
5854 IFS=$as_save_IFS
5855 test -z "$as_dir" && as_dir=.
5856 for ac_exec_ext in '' $ac_executable_extensions; do
5857 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5858 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5859 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5860 break 2
5861 fi
5862 done
5863 done
5864 IFS=$as_save_IFS
5865
5866 ;;
5867 esac
5868 fi
5869 CUT=$ac_cv_path_CUT
5870 if test -n "$CUT"; then
5871 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5872 $as_echo "$CUT" >&6; }
5873 else
5874 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5875 $as_echo "no" >&6; }
5876 fi
5877
5878
5879 test -n "$CUT" && break
5880 done
5881
5882 else
5883 # If it succeeded, then it was overridden by the user. We will use it
5884 # for the tool.
5885
5886 # First remove it from the list of overridden variables, so we can test
5887 # for unknown variables in the end.
5888 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5889
5890 # Check if the provided tool contains a complete path.
5891 tool_specified="$CUT"
5892 tool_basename="${tool_specified##*/}"
5893 if test "x$tool_basename" = "x$tool_specified"; then
5894 # A command without a complete path is provided, search $PATH.
5895 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5896 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5897 # Extract the first word of "$tool_basename", so it can be a program name with args.
5898 set dummy $tool_basename; ac_word=$2
5899 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5900 $as_echo_n "checking for $ac_word... " >&6; }
5901 if ${ac_cv_path_CUT+:} false; then :
5902 $as_echo_n "(cached) " >&6
5903 else
5904 case $CUT in
5905 [\\/]* | ?:[\\/]*)
5906 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5907 ;;
5908 *)
5909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5910 for as_dir in $PATH
5911 do
5912 IFS=$as_save_IFS
5913 test -z "$as_dir" && as_dir=.
5914 for ac_exec_ext in '' $ac_executable_extensions; do
5915 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5916 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5917 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5918 break 2
5919 fi
5920 done
5921 done
5922 IFS=$as_save_IFS
5923
5924 ;;
5925 esac
5926 fi
5927 CUT=$ac_cv_path_CUT
5928 if test -n "$CUT"; then
5929 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5930 $as_echo "$CUT" >&6; }
5931 else
5932 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5933 $as_echo "no" >&6; }
5934 fi
5935
5936
5937 if test "x$CUT" = x; then
5938 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5939 fi
5940 else
5941 # Otherwise we believe it is a complete path. Use it as it is.
5942 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5943 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5944 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5945 $as_echo_n "checking for CUT... " >&6; }
5946 if test ! -x "$tool_specified"; then
5947 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5948 $as_echo "not found" >&6; }
5949 as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5950 fi
5951 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5952 $as_echo "$tool_specified" >&6; }
5953 fi
5954 fi
5955 fi
5956
5957
5958
5959 if test "x$CUT" = x; then
5960 as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5961 fi
5962
5963
5964
5965
5966
5967 # Publish this variable in the help.
5968
5969
5970 if test "x$DATE" = x; then
5971 # The variable is not set by user, try to locate tool using the code snippet
5972 for ac_prog in date
5973 do
5974 # Extract the first word of "$ac_prog", so it can be a program name with args.
5975 set dummy $ac_prog; ac_word=$2
5976 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5977 $as_echo_n "checking for $ac_word... " >&6; }
5978 if ${ac_cv_path_DATE+:} false; then :
5979 $as_echo_n "(cached) " >&6
5980 else
5981 case $DATE in
5982 [\\/]* | ?:[\\/]*)
5983 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5984 ;;
5985 *)
5986 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5987 for as_dir in $PATH
5988 do
5989 IFS=$as_save_IFS
5990 test -z "$as_dir" && as_dir=.
5991 for ac_exec_ext in '' $ac_executable_extensions; do
5992 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5993 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5994 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5995 break 2
5996 fi
5997 done
5998 done
5999 IFS=$as_save_IFS
6000
6001 ;;
6002 esac
6003 fi
6004 DATE=$ac_cv_path_DATE
6005 if test -n "$DATE"; then
6006 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6007 $as_echo "$DATE" >&6; }
6008 else
6009 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6010 $as_echo "no" >&6; }
6011 fi
6012
6013
6014 test -n "$DATE" && break
6015 done
6016
6017 else
6018 # The variable is set, but is it from the command line or the environment?
6019
6020 # Try to remove the string !DATE! from our list.
6021 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6022 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6023 # If it failed, the variable was not from the command line. Ignore it,
6024 # but warn the user (except for BASH, which is always set by the calling BASH).
6025 if test "xDATE" != xBASH; then
6026 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6027 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6028 fi
6029 # Try to locate tool using the code snippet
6030 for ac_prog in date
6031 do
6032 # Extract the first word of "$ac_prog", so it can be a program name with args.
6033 set dummy $ac_prog; ac_word=$2
6034 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6035 $as_echo_n "checking for $ac_word... " >&6; }
6036 if ${ac_cv_path_DATE+:} false; then :
6037 $as_echo_n "(cached) " >&6
6038 else
6039 case $DATE in
6040 [\\/]* | ?:[\\/]*)
6041 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6042 ;;
6043 *)
6044 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6045 for as_dir in $PATH
6046 do
6047 IFS=$as_save_IFS
6048 test -z "$as_dir" && as_dir=.
6049 for ac_exec_ext in '' $ac_executable_extensions; do
6050 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6051 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6052 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6053 break 2
6054 fi
6055 done
6056 done
6057 IFS=$as_save_IFS
6058
6059 ;;
6060 esac
6061 fi
6062 DATE=$ac_cv_path_DATE
6063 if test -n "$DATE"; then
6064 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6065 $as_echo "$DATE" >&6; }
6066 else
6067 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6068 $as_echo "no" >&6; }
6069 fi
6070
6071
6072 test -n "$DATE" && break
6073 done
6074
6075 else
6076 # If it succeeded, then it was overridden by the user. We will use it
6077 # for the tool.
6078
6079 # First remove it from the list of overridden variables, so we can test
6080 # for unknown variables in the end.
6081 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6082
6083 # Check if the provided tool contains a complete path.
6084 tool_specified="$DATE"
6085 tool_basename="${tool_specified##*/}"
6086 if test "x$tool_basename" = "x$tool_specified"; then
6087 # A command without a complete path is provided, search $PATH.
6088 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6089 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6090 # Extract the first word of "$tool_basename", so it can be a program name with args.
6091 set dummy $tool_basename; ac_word=$2
6092 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6093 $as_echo_n "checking for $ac_word... " >&6; }
6094 if ${ac_cv_path_DATE+:} false; then :
6095 $as_echo_n "(cached) " >&6
6096 else
6097 case $DATE in
6098 [\\/]* | ?:[\\/]*)
6099 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6100 ;;
6101 *)
6102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6103 for as_dir in $PATH
6104 do
6105 IFS=$as_save_IFS
6106 test -z "$as_dir" && as_dir=.
6107 for ac_exec_ext in '' $ac_executable_extensions; do
6108 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6109 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6110 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6111 break 2
6112 fi
6113 done
6114 done
6115 IFS=$as_save_IFS
6116
6117 ;;
6118 esac
6119 fi
6120 DATE=$ac_cv_path_DATE
6121 if test -n "$DATE"; then
6122 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6123 $as_echo "$DATE" >&6; }
6124 else
6125 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6126 $as_echo "no" >&6; }
6127 fi
6128
6129
6130 if test "x$DATE" = x; then
6131 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6132 fi
6133 else
6134 # Otherwise we believe it is a complete path. Use it as it is.
6135 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6136 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6137 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6138 $as_echo_n "checking for DATE... " >&6; }
6139 if test ! -x "$tool_specified"; then
6140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6141 $as_echo "not found" >&6; }
6142 as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6143 fi
6144 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6145 $as_echo "$tool_specified" >&6; }
6146 fi
6147 fi
6148 fi
6149
6150
6151
6152 if test "x$DATE" = x; then
6153 as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6154 fi
6155
6156
6157
6158
6159
6160 # Publish this variable in the help.
6161
6162
6163 if test "x$DIFF" = x; then
6164 # The variable is not set by user, try to locate tool using the code snippet
6165 for ac_prog in gdiff diff
6166 do
6167 # Extract the first word of "$ac_prog", so it can be a program name with args.
6168 set dummy $ac_prog; ac_word=$2
6169 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6170 $as_echo_n "checking for $ac_word... " >&6; }
6171 if ${ac_cv_path_DIFF+:} false; then :
6172 $as_echo_n "(cached) " >&6
6173 else
6174 case $DIFF in
6175 [\\/]* | ?:[\\/]*)
6176 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6177 ;;
6178 *)
6179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6180 for as_dir in $PATH
6181 do
6182 IFS=$as_save_IFS
6183 test -z "$as_dir" && as_dir=.
6184 for ac_exec_ext in '' $ac_executable_extensions; do
6185 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6186 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6187 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6188 break 2
6189 fi
6190 done
6191 done
6192 IFS=$as_save_IFS
6193
6194 ;;
6195 esac
6196 fi
6197 DIFF=$ac_cv_path_DIFF
6198 if test -n "$DIFF"; then
6199 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6200 $as_echo "$DIFF" >&6; }
6201 else
6202 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6203 $as_echo "no" >&6; }
6204 fi
6205
6206
6207 test -n "$DIFF" && break
6208 done
6209
6210 else
6211 # The variable is set, but is it from the command line or the environment?
6212
6213 # Try to remove the string !DIFF! from our list.
6214 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6215 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6216 # If it failed, the variable was not from the command line. Ignore it,
6217 # but warn the user (except for BASH, which is always set by the calling BASH).
6218 if test "xDIFF" != xBASH; then
6219 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6220 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6221 fi
6222 # Try to locate tool using the code snippet
6223 for ac_prog in gdiff diff
6224 do
6225 # Extract the first word of "$ac_prog", so it can be a program name with args.
6226 set dummy $ac_prog; ac_word=$2
6227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6228 $as_echo_n "checking for $ac_word... " >&6; }
6229 if ${ac_cv_path_DIFF+:} false; then :
6230 $as_echo_n "(cached) " >&6
6231 else
6232 case $DIFF in
6233 [\\/]* | ?:[\\/]*)
6234 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6235 ;;
6236 *)
6237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6238 for as_dir in $PATH
6239 do
6240 IFS=$as_save_IFS
6241 test -z "$as_dir" && as_dir=.
6242 for ac_exec_ext in '' $ac_executable_extensions; do
6243 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6244 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6245 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6246 break 2
6247 fi
6248 done
6249 done
6250 IFS=$as_save_IFS
6251
6252 ;;
6253 esac
6254 fi
6255 DIFF=$ac_cv_path_DIFF
6256 if test -n "$DIFF"; then
6257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6258 $as_echo "$DIFF" >&6; }
6259 else
6260 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6261 $as_echo "no" >&6; }
6262 fi
6263
6264
6265 test -n "$DIFF" && break
6266 done
6267
6268 else
6269 # If it succeeded, then it was overridden by the user. We will use it
6270 # for the tool.
6271
6272 # First remove it from the list of overridden variables, so we can test
6273 # for unknown variables in the end.
6274 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6275
6276 # Check if the provided tool contains a complete path.
6277 tool_specified="$DIFF"
6278 tool_basename="${tool_specified##*/}"
6279 if test "x$tool_basename" = "x$tool_specified"; then
6280 # A command without a complete path is provided, search $PATH.
6281 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6282 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6283 # Extract the first word of "$tool_basename", so it can be a program name with args.
6284 set dummy $tool_basename; ac_word=$2
6285 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6286 $as_echo_n "checking for $ac_word... " >&6; }
6287 if ${ac_cv_path_DIFF+:} false; then :
6288 $as_echo_n "(cached) " >&6
6289 else
6290 case $DIFF in
6291 [\\/]* | ?:[\\/]*)
6292 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6293 ;;
6294 *)
6295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6296 for as_dir in $PATH
6297 do
6298 IFS=$as_save_IFS
6299 test -z "$as_dir" && as_dir=.
6300 for ac_exec_ext in '' $ac_executable_extensions; do
6301 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6302 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6303 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6304 break 2
6305 fi
6306 done
6307 done
6308 IFS=$as_save_IFS
6309
6310 ;;
6311 esac
6312 fi
6313 DIFF=$ac_cv_path_DIFF
6314 if test -n "$DIFF"; then
6315 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6316 $as_echo "$DIFF" >&6; }
6317 else
6318 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6319 $as_echo "no" >&6; }
6320 fi
6321
6322
6323 if test "x$DIFF" = x; then
6324 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6325 fi
6326 else
6327 # Otherwise we believe it is a complete path. Use it as it is.
6328 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6329 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6330 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6331 $as_echo_n "checking for DIFF... " >&6; }
6332 if test ! -x "$tool_specified"; then
6333 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6334 $as_echo "not found" >&6; }
6335 as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6336 fi
6337 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6338 $as_echo "$tool_specified" >&6; }
6339 fi
6340 fi
6341 fi
6342
6343
6344
6345 if test "x$DIFF" = x; then
6346 as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6347 fi
6348
6349
6350
6351
6352
6353 # Publish this variable in the help.
6354
6355
6356 if test "x$DIRNAME" = x; then
6357 # The variable is not set by user, try to locate tool using the code snippet
6358 for ac_prog in dirname
6359 do
6360 # Extract the first word of "$ac_prog", so it can be a program name with args.
6361 set dummy $ac_prog; ac_word=$2
6362 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6363 $as_echo_n "checking for $ac_word... " >&6; }
6364 if ${ac_cv_path_DIRNAME+:} false; then :
6365 $as_echo_n "(cached) " >&6
6366 else
6367 case $DIRNAME in
6368 [\\/]* | ?:[\\/]*)
6369 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6370 ;;
6371 *)
6372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6373 for as_dir in $PATH
6374 do
6375 IFS=$as_save_IFS
6376 test -z "$as_dir" && as_dir=.
6377 for ac_exec_ext in '' $ac_executable_extensions; do
6378 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6379 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6380 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6381 break 2
6382 fi
6383 done
6384 done
6385 IFS=$as_save_IFS
6386
6387 ;;
6388 esac
6389 fi
6390 DIRNAME=$ac_cv_path_DIRNAME
6391 if test -n "$DIRNAME"; then
6392 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6393 $as_echo "$DIRNAME" >&6; }
6394 else
6395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6396 $as_echo "no" >&6; }
6397 fi
6398
6399
6400 test -n "$DIRNAME" && break
6401 done
6402
6403 else
6404 # The variable is set, but is it from the command line or the environment?
6405
6406 # Try to remove the string !DIRNAME! from our list.
6407 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6408 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6409 # If it failed, the variable was not from the command line. Ignore it,
6410 # but warn the user (except for BASH, which is always set by the calling BASH).
6411 if test "xDIRNAME" != xBASH; then
6412 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6413 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6414 fi
6415 # Try to locate tool using the code snippet
6416 for ac_prog in dirname
6417 do
6418 # Extract the first word of "$ac_prog", so it can be a program name with args.
6419 set dummy $ac_prog; ac_word=$2
6420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6421 $as_echo_n "checking for $ac_word... " >&6; }
6422 if ${ac_cv_path_DIRNAME+:} false; then :
6423 $as_echo_n "(cached) " >&6
6424 else
6425 case $DIRNAME in
6426 [\\/]* | ?:[\\/]*)
6427 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6428 ;;
6429 *)
6430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6431 for as_dir in $PATH
6432 do
6433 IFS=$as_save_IFS
6434 test -z "$as_dir" && as_dir=.
6435 for ac_exec_ext in '' $ac_executable_extensions; do
6436 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6437 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6438 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6439 break 2
6440 fi
6441 done
6442 done
6443 IFS=$as_save_IFS
6444
6445 ;;
6446 esac
6447 fi
6448 DIRNAME=$ac_cv_path_DIRNAME
6449 if test -n "$DIRNAME"; then
6450 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6451 $as_echo "$DIRNAME" >&6; }
6452 else
6453 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6454 $as_echo "no" >&6; }
6455 fi
6456
6457
6458 test -n "$DIRNAME" && break
6459 done
6460
6461 else
6462 # If it succeeded, then it was overridden by the user. We will use it
6463 # for the tool.
6464
6465 # First remove it from the list of overridden variables, so we can test
6466 # for unknown variables in the end.
6467 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6468
6469 # Check if the provided tool contains a complete path.
6470 tool_specified="$DIRNAME"
6471 tool_basename="${tool_specified##*/}"
6472 if test "x$tool_basename" = "x$tool_specified"; then
6473 # A command without a complete path is provided, search $PATH.
6474 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6475 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6476 # Extract the first word of "$tool_basename", so it can be a program name with args.
6477 set dummy $tool_basename; ac_word=$2
6478 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6479 $as_echo_n "checking for $ac_word... " >&6; }
6480 if ${ac_cv_path_DIRNAME+:} false; then :
6481 $as_echo_n "(cached) " >&6
6482 else
6483 case $DIRNAME in
6484 [\\/]* | ?:[\\/]*)
6485 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6486 ;;
6487 *)
6488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6489 for as_dir in $PATH
6490 do
6491 IFS=$as_save_IFS
6492 test -z "$as_dir" && as_dir=.
6493 for ac_exec_ext in '' $ac_executable_extensions; do
6494 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6495 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6496 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6497 break 2
6498 fi
6499 done
6500 done
6501 IFS=$as_save_IFS
6502
6503 ;;
6504 esac
6505 fi
6506 DIRNAME=$ac_cv_path_DIRNAME
6507 if test -n "$DIRNAME"; then
6508 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6509 $as_echo "$DIRNAME" >&6; }
6510 else
6511 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6512 $as_echo "no" >&6; }
6513 fi
6514
6515
6516 if test "x$DIRNAME" = x; then
6517 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6518 fi
6519 else
6520 # Otherwise we believe it is a complete path. Use it as it is.
6521 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6522 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6524 $as_echo_n "checking for DIRNAME... " >&6; }
6525 if test ! -x "$tool_specified"; then
6526 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6527 $as_echo "not found" >&6; }
6528 as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6529 fi
6530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6531 $as_echo "$tool_specified" >&6; }
6532 fi
6533 fi
6534 fi
6535
6536
6537
6538 if test "x$DIRNAME" = x; then
6539 as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6540 fi
6541
6542
6543
6544
6545
6546 # Publish this variable in the help.
6547
6548
6549 if test "x$ECHO" = x; then
6550 # The variable is not set by user, try to locate tool using the code snippet
6551 for ac_prog in echo
6552 do
6553 # Extract the first word of "$ac_prog", so it can be a program name with args.
6554 set dummy $ac_prog; ac_word=$2
6555 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6556 $as_echo_n "checking for $ac_word... " >&6; }
6557 if ${ac_cv_path_ECHO+:} false; then :
6558 $as_echo_n "(cached) " >&6
6559 else
6560 case $ECHO in
6561 [\\/]* | ?:[\\/]*)
6562 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6563 ;;
6564 *)
6565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6566 for as_dir in $PATH
6567 do
6568 IFS=$as_save_IFS
6569 test -z "$as_dir" && as_dir=.
6570 for ac_exec_ext in '' $ac_executable_extensions; do
6571 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6572 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6573 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6574 break 2
6575 fi
6576 done
6577 done
6578 IFS=$as_save_IFS
6579
6580 ;;
6581 esac
6582 fi
6583 ECHO=$ac_cv_path_ECHO
6584 if test -n "$ECHO"; then
6585 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6586 $as_echo "$ECHO" >&6; }
6587 else
6588 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6589 $as_echo "no" >&6; }
6590 fi
6591
6592
6593 test -n "$ECHO" && break
6594 done
6595
6596 else
6597 # The variable is set, but is it from the command line or the environment?
6598
6599 # Try to remove the string !ECHO! from our list.
6600 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6601 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6602 # If it failed, the variable was not from the command line. Ignore it,
6603 # but warn the user (except for BASH, which is always set by the calling BASH).
6604 if test "xECHO" != xBASH; then
6605 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6606 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6607 fi
6608 # Try to locate tool using the code snippet
6609 for ac_prog in echo
6610 do
6611 # Extract the first word of "$ac_prog", so it can be a program name with args.
6612 set dummy $ac_prog; ac_word=$2
6613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6614 $as_echo_n "checking for $ac_word... " >&6; }
6615 if ${ac_cv_path_ECHO+:} false; then :
6616 $as_echo_n "(cached) " >&6
6617 else
6618 case $ECHO in
6619 [\\/]* | ?:[\\/]*)
6620 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6621 ;;
6622 *)
6623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6624 for as_dir in $PATH
6625 do
6626 IFS=$as_save_IFS
6627 test -z "$as_dir" && as_dir=.
6628 for ac_exec_ext in '' $ac_executable_extensions; do
6629 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6630 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6631 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6632 break 2
6633 fi
6634 done
6635 done
6636 IFS=$as_save_IFS
6637
6638 ;;
6639 esac
6640 fi
6641 ECHO=$ac_cv_path_ECHO
6642 if test -n "$ECHO"; then
6643 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6644 $as_echo "$ECHO" >&6; }
6645 else
6646 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6647 $as_echo "no" >&6; }
6648 fi
6649
6650
6651 test -n "$ECHO" && break
6652 done
6653
6654 else
6655 # If it succeeded, then it was overridden by the user. We will use it
6656 # for the tool.
6657
6658 # First remove it from the list of overridden variables, so we can test
6659 # for unknown variables in the end.
6660 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6661
6662 # Check if the provided tool contains a complete path.
6663 tool_specified="$ECHO"
6664 tool_basename="${tool_specified##*/}"
6665 if test "x$tool_basename" = "x$tool_specified"; then
6666 # A command without a complete path is provided, search $PATH.
6667 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6668 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6669 # Extract the first word of "$tool_basename", so it can be a program name with args.
6670 set dummy $tool_basename; ac_word=$2
6671 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6672 $as_echo_n "checking for $ac_word... " >&6; }
6673 if ${ac_cv_path_ECHO+:} false; then :
6674 $as_echo_n "(cached) " >&6
6675 else
6676 case $ECHO in
6677 [\\/]* | ?:[\\/]*)
6678 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6679 ;;
6680 *)
6681 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6682 for as_dir in $PATH
6683 do
6684 IFS=$as_save_IFS
6685 test -z "$as_dir" && as_dir=.
6686 for ac_exec_ext in '' $ac_executable_extensions; do
6687 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6688 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6689 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6690 break 2
6691 fi
6692 done
6693 done
6694 IFS=$as_save_IFS
6695
6696 ;;
6697 esac
6698 fi
6699 ECHO=$ac_cv_path_ECHO
6700 if test -n "$ECHO"; then
6701 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6702 $as_echo "$ECHO" >&6; }
6703 else
6704 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6705 $as_echo "no" >&6; }
6706 fi
6707
6708
6709 if test "x$ECHO" = x; then
6710 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6711 fi
6712 else
6713 # Otherwise we believe it is a complete path. Use it as it is.
6714 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6715 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6717 $as_echo_n "checking for ECHO... " >&6; }
6718 if test ! -x "$tool_specified"; then
6719 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6720 $as_echo "not found" >&6; }
6721 as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6722 fi
6723 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6724 $as_echo "$tool_specified" >&6; }
6725 fi
6726 fi
6727 fi
6728
6729
6730
6731 if test "x$ECHO" = x; then
6732 as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6733 fi
6734
6735
6736
6737
6738
6739 # Publish this variable in the help.
6740
6741
6742 if test "x$EXPR" = x; then
6743 # The variable is not set by user, try to locate tool using the code snippet
6744 for ac_prog in expr
6745 do
6746 # Extract the first word of "$ac_prog", so it can be a program name with args.
6747 set dummy $ac_prog; ac_word=$2
6748 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6749 $as_echo_n "checking for $ac_word... " >&6; }
6750 if ${ac_cv_path_EXPR+:} false; then :
6751 $as_echo_n "(cached) " >&6
6752 else
6753 case $EXPR in
6754 [\\/]* | ?:[\\/]*)
6755 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6756 ;;
6757 *)
6758 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6759 for as_dir in $PATH
6760 do
6761 IFS=$as_save_IFS
6762 test -z "$as_dir" && as_dir=.
6763 for ac_exec_ext in '' $ac_executable_extensions; do
6764 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6765 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6766 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6767 break 2
6768 fi
6769 done
6770 done
6771 IFS=$as_save_IFS
6772
6773 ;;
6774 esac
6775 fi
6776 EXPR=$ac_cv_path_EXPR
6777 if test -n "$EXPR"; then
6778 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6779 $as_echo "$EXPR" >&6; }
6780 else
6781 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6782 $as_echo "no" >&6; }
6783 fi
6784
6785
6786 test -n "$EXPR" && break
6787 done
6788
6789 else
6790 # The variable is set, but is it from the command line or the environment?
6791
6792 # Try to remove the string !EXPR! from our list.
6793 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6794 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6795 # If it failed, the variable was not from the command line. Ignore it,
6796 # but warn the user (except for BASH, which is always set by the calling BASH).
6797 if test "xEXPR" != xBASH; then
6798 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6799 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6800 fi
6801 # Try to locate tool using the code snippet
6802 for ac_prog in expr
6803 do
6804 # Extract the first word of "$ac_prog", so it can be a program name with args.
6805 set dummy $ac_prog; ac_word=$2
6806 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6807 $as_echo_n "checking for $ac_word... " >&6; }
6808 if ${ac_cv_path_EXPR+:} false; then :
6809 $as_echo_n "(cached) " >&6
6810 else
6811 case $EXPR in
6812 [\\/]* | ?:[\\/]*)
6813 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6814 ;;
6815 *)
6816 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6817 for as_dir in $PATH
6818 do
6819 IFS=$as_save_IFS
6820 test -z "$as_dir" && as_dir=.
6821 for ac_exec_ext in '' $ac_executable_extensions; do
6822 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6823 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6824 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6825 break 2
6826 fi
6827 done
6828 done
6829 IFS=$as_save_IFS
6830
6831 ;;
6832 esac
6833 fi
6834 EXPR=$ac_cv_path_EXPR
6835 if test -n "$EXPR"; then
6836 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6837 $as_echo "$EXPR" >&6; }
6838 else
6839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6840 $as_echo "no" >&6; }
6841 fi
6842
6843
6844 test -n "$EXPR" && break
6845 done
6846
6847 else
6848 # If it succeeded, then it was overridden by the user. We will use it
6849 # for the tool.
6850
6851 # First remove it from the list of overridden variables, so we can test
6852 # for unknown variables in the end.
6853 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6854
6855 # Check if the provided tool contains a complete path.
6856 tool_specified="$EXPR"
6857 tool_basename="${tool_specified##*/}"
6858 if test "x$tool_basename" = "x$tool_specified"; then
6859 # A command without a complete path is provided, search $PATH.
6860 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6861 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6862 # Extract the first word of "$tool_basename", so it can be a program name with args.
6863 set dummy $tool_basename; ac_word=$2
6864 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6865 $as_echo_n "checking for $ac_word... " >&6; }
6866 if ${ac_cv_path_EXPR+:} false; then :
6867 $as_echo_n "(cached) " >&6
6868 else
6869 case $EXPR in
6870 [\\/]* | ?:[\\/]*)
6871 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6872 ;;
6873 *)
6874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6875 for as_dir in $PATH
6876 do
6877 IFS=$as_save_IFS
6878 test -z "$as_dir" && as_dir=.
6879 for ac_exec_ext in '' $ac_executable_extensions; do
6880 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6881 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6882 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6883 break 2
6884 fi
6885 done
6886 done
6887 IFS=$as_save_IFS
6888
6889 ;;
6890 esac
6891 fi
6892 EXPR=$ac_cv_path_EXPR
6893 if test -n "$EXPR"; then
6894 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6895 $as_echo "$EXPR" >&6; }
6896 else
6897 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6898 $as_echo "no" >&6; }
6899 fi
6900
6901
6902 if test "x$EXPR" = x; then
6903 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6904 fi
6905 else
6906 # Otherwise we believe it is a complete path. Use it as it is.
6907 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6908 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6909 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6910 $as_echo_n "checking for EXPR... " >&6; }
6911 if test ! -x "$tool_specified"; then
6912 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6913 $as_echo "not found" >&6; }
6914 as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6915 fi
6916 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6917 $as_echo "$tool_specified" >&6; }
6918 fi
6919 fi
6920 fi
6921
6922
6923
6924 if test "x$EXPR" = x; then
6925 as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6926 fi
6927
6928
6929
6930
6931
6932 # Publish this variable in the help.
6933
6934
6935 if test "x$FILE" = x; then
6936 # The variable is not set by user, try to locate tool using the code snippet
6937 for ac_prog in file
6938 do
6939 # Extract the first word of "$ac_prog", so it can be a program name with args.
6940 set dummy $ac_prog; ac_word=$2
6941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6942 $as_echo_n "checking for $ac_word... " >&6; }
6943 if ${ac_cv_path_FILE+:} false; then :
6944 $as_echo_n "(cached) " >&6
6945 else
6946 case $FILE in
6947 [\\/]* | ?:[\\/]*)
6948 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6949 ;;
6950 *)
6951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6952 for as_dir in $PATH
6953 do
6954 IFS=$as_save_IFS
6955 test -z "$as_dir" && as_dir=.
6956 for ac_exec_ext in '' $ac_executable_extensions; do
6957 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6958 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6959 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6960 break 2
6961 fi
6962 done
6963 done
6964 IFS=$as_save_IFS
6965
6966 ;;
6967 esac
6968 fi
6969 FILE=$ac_cv_path_FILE
6970 if test -n "$FILE"; then
6971 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6972 $as_echo "$FILE" >&6; }
6973 else
6974 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6975 $as_echo "no" >&6; }
6976 fi
6977
6978
6979 test -n "$FILE" && break
6980 done
6981
6982 else
6983 # The variable is set, but is it from the command line or the environment?
6984
6985 # Try to remove the string !FILE! from our list.
6986 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6987 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6988 # If it failed, the variable was not from the command line. Ignore it,
6989 # but warn the user (except for BASH, which is always set by the calling BASH).
6990 if test "xFILE" != xBASH; then
6991 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6992 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6993 fi
6994 # Try to locate tool using the code snippet
6995 for ac_prog in file
6996 do
6997 # Extract the first word of "$ac_prog", so it can be a program name with args.
6998 set dummy $ac_prog; ac_word=$2
6999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7000 $as_echo_n "checking for $ac_word... " >&6; }
7001 if ${ac_cv_path_FILE+:} false; then :
7002 $as_echo_n "(cached) " >&6
7003 else
7004 case $FILE in
7005 [\\/]* | ?:[\\/]*)
7006 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7007 ;;
7008 *)
7009 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7010 for as_dir in $PATH
7011 do
7012 IFS=$as_save_IFS
7013 test -z "$as_dir" && as_dir=.
7014 for ac_exec_ext in '' $ac_executable_extensions; do
7015 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7016 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7017 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7018 break 2
7019 fi
7020 done
7021 done
7022 IFS=$as_save_IFS
7023
7024 ;;
7025 esac
7026 fi
7027 FILE=$ac_cv_path_FILE
7028 if test -n "$FILE"; then
7029 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7030 $as_echo "$FILE" >&6; }
7031 else
7032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7033 $as_echo "no" >&6; }
7034 fi
7035
7036
7037 test -n "$FILE" && break
7038 done
7039
7040 else
7041 # If it succeeded, then it was overridden by the user. We will use it
7042 # for the tool.
7043
7044 # First remove it from the list of overridden variables, so we can test
7045 # for unknown variables in the end.
7046 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7047
7048 # Check if the provided tool contains a complete path.
7049 tool_specified="$FILE"
7050 tool_basename="${tool_specified##*/}"
7051 if test "x$tool_basename" = "x$tool_specified"; then
7052 # A command without a complete path is provided, search $PATH.
7053 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7054 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7055 # Extract the first word of "$tool_basename", so it can be a program name with args.
7056 set dummy $tool_basename; ac_word=$2
7057 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7058 $as_echo_n "checking for $ac_word... " >&6; }
7059 if ${ac_cv_path_FILE+:} false; then :
7060 $as_echo_n "(cached) " >&6
7061 else
7062 case $FILE in
7063 [\\/]* | ?:[\\/]*)
7064 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7065 ;;
7066 *)
7067 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7068 for as_dir in $PATH
7069 do
7070 IFS=$as_save_IFS
7071 test -z "$as_dir" && as_dir=.
7072 for ac_exec_ext in '' $ac_executable_extensions; do
7073 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7074 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7075 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7076 break 2
7077 fi
7078 done
7079 done
7080 IFS=$as_save_IFS
7081
7082 ;;
7083 esac
7084 fi
7085 FILE=$ac_cv_path_FILE
7086 if test -n "$FILE"; then
7087 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7088 $as_echo "$FILE" >&6; }
7089 else
7090 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7091 $as_echo "no" >&6; }
7092 fi
7093
7094
7095 if test "x$FILE" = x; then
7096 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7097 fi
7098 else
7099 # Otherwise we believe it is a complete path. Use it as it is.
7100 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7101 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7103 $as_echo_n "checking for FILE... " >&6; }
7104 if test ! -x "$tool_specified"; then
7105 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7106 $as_echo "not found" >&6; }
7107 as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7108 fi
7109 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7110 $as_echo "$tool_specified" >&6; }
7111 fi
7112 fi
7113 fi
7114
7115
7116
7117 if test "x$FILE" = x; then
7118 as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7119 fi
7120
7121
7122
7123
7124
7125 # Publish this variable in the help.
7126
7127
7128 if test "x$FIND" = x; then
7129 # The variable is not set by user, try to locate tool using the code snippet
7130 for ac_prog in find
7131 do
7132 # Extract the first word of "$ac_prog", so it can be a program name with args.
7133 set dummy $ac_prog; ac_word=$2
7134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7135 $as_echo_n "checking for $ac_word... " >&6; }
7136 if ${ac_cv_path_FIND+:} false; then :
7137 $as_echo_n "(cached) " >&6
7138 else
7139 case $FIND in
7140 [\\/]* | ?:[\\/]*)
7141 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7142 ;;
7143 *)
7144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7145 for as_dir in $PATH
7146 do
7147 IFS=$as_save_IFS
7148 test -z "$as_dir" && as_dir=.
7149 for ac_exec_ext in '' $ac_executable_extensions; do
7150 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7151 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7152 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7153 break 2
7154 fi
7155 done
7156 done
7157 IFS=$as_save_IFS
7158
7159 ;;
7160 esac
7161 fi
7162 FIND=$ac_cv_path_FIND
7163 if test -n "$FIND"; then
7164 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7165 $as_echo "$FIND" >&6; }
7166 else
7167 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7168 $as_echo "no" >&6; }
7169 fi
7170
7171
7172 test -n "$FIND" && break
7173 done
7174
7175 else
7176 # The variable is set, but is it from the command line or the environment?
7177
7178 # Try to remove the string !FIND! from our list.
7179 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7180 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7181 # If it failed, the variable was not from the command line. Ignore it,
7182 # but warn the user (except for BASH, which is always set by the calling BASH).
7183 if test "xFIND" != xBASH; then
7184 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7185 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7186 fi
7187 # Try to locate tool using the code snippet
7188 for ac_prog in find
7189 do
7190 # Extract the first word of "$ac_prog", so it can be a program name with args.
7191 set dummy $ac_prog; ac_word=$2
7192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7193 $as_echo_n "checking for $ac_word... " >&6; }
7194 if ${ac_cv_path_FIND+:} false; then :
7195 $as_echo_n "(cached) " >&6
7196 else
7197 case $FIND in
7198 [\\/]* | ?:[\\/]*)
7199 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7200 ;;
7201 *)
7202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7203 for as_dir in $PATH
7204 do
7205 IFS=$as_save_IFS
7206 test -z "$as_dir" && as_dir=.
7207 for ac_exec_ext in '' $ac_executable_extensions; do
7208 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7209 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7210 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7211 break 2
7212 fi
7213 done
7214 done
7215 IFS=$as_save_IFS
7216
7217 ;;
7218 esac
7219 fi
7220 FIND=$ac_cv_path_FIND
7221 if test -n "$FIND"; then
7222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7223 $as_echo "$FIND" >&6; }
7224 else
7225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7226 $as_echo "no" >&6; }
7227 fi
7228
7229
7230 test -n "$FIND" && break
7231 done
7232
7233 else
7234 # If it succeeded, then it was overridden by the user. We will use it
7235 # for the tool.
7236
7237 # First remove it from the list of overridden variables, so we can test
7238 # for unknown variables in the end.
7239 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7240
7241 # Check if the provided tool contains a complete path.
7242 tool_specified="$FIND"
7243 tool_basename="${tool_specified##*/}"
7244 if test "x$tool_basename" = "x$tool_specified"; then
7245 # A command without a complete path is provided, search $PATH.
7246 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7247 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7248 # Extract the first word of "$tool_basename", so it can be a program name with args.
7249 set dummy $tool_basename; ac_word=$2
7250 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7251 $as_echo_n "checking for $ac_word... " >&6; }
7252 if ${ac_cv_path_FIND+:} false; then :
7253 $as_echo_n "(cached) " >&6
7254 else
7255 case $FIND in
7256 [\\/]* | ?:[\\/]*)
7257 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7258 ;;
7259 *)
7260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7261 for as_dir in $PATH
7262 do
7263 IFS=$as_save_IFS
7264 test -z "$as_dir" && as_dir=.
7265 for ac_exec_ext in '' $ac_executable_extensions; do
7266 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7267 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7268 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7269 break 2
7270 fi
7271 done
7272 done
7273 IFS=$as_save_IFS
7274
7275 ;;
7276 esac
7277 fi
7278 FIND=$ac_cv_path_FIND
7279 if test -n "$FIND"; then
7280 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7281 $as_echo "$FIND" >&6; }
7282 else
7283 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7284 $as_echo "no" >&6; }
7285 fi
7286
7287
7288 if test "x$FIND" = x; then
7289 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7290 fi
7291 else
7292 # Otherwise we believe it is a complete path. Use it as it is.
7293 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7294 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7296 $as_echo_n "checking for FIND... " >&6; }
7297 if test ! -x "$tool_specified"; then
7298 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7299 $as_echo "not found" >&6; }
7300 as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7301 fi
7302 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7303 $as_echo "$tool_specified" >&6; }
7304 fi
7305 fi
7306 fi
7307
7308
7309
7310 if test "x$FIND" = x; then
7311 as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7312 fi
7313
7314
7315
7316
7317
7318 # Publish this variable in the help.
7319
7320
7321 if test "x$HEAD" = x; then
7322 # The variable is not set by user, try to locate tool using the code snippet
7323 for ac_prog in head
7324 do
7325 # Extract the first word of "$ac_prog", so it can be a program name with args.
7326 set dummy $ac_prog; ac_word=$2
7327 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7328 $as_echo_n "checking for $ac_word... " >&6; }
7329 if ${ac_cv_path_HEAD+:} false; then :
7330 $as_echo_n "(cached) " >&6
7331 else
7332 case $HEAD in
7333 [\\/]* | ?:[\\/]*)
7334 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7335 ;;
7336 *)
7337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7338 for as_dir in $PATH
7339 do
7340 IFS=$as_save_IFS
7341 test -z "$as_dir" && as_dir=.
7342 for ac_exec_ext in '' $ac_executable_extensions; do
7343 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7344 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7345 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7346 break 2
7347 fi
7348 done
7349 done
7350 IFS=$as_save_IFS
7351
7352 ;;
7353 esac
7354 fi
7355 HEAD=$ac_cv_path_HEAD
7356 if test -n "$HEAD"; then
7357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7358 $as_echo "$HEAD" >&6; }
7359 else
7360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7361 $as_echo "no" >&6; }
7362 fi
7363
7364
7365 test -n "$HEAD" && break
7366 done
7367
7368 else
7369 # The variable is set, but is it from the command line or the environment?
7370
7371 # Try to remove the string !HEAD! from our list.
7372 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7373 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7374 # If it failed, the variable was not from the command line. Ignore it,
7375 # but warn the user (except for BASH, which is always set by the calling BASH).
7376 if test "xHEAD" != xBASH; then
7377 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7378 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7379 fi
7380 # Try to locate tool using the code snippet
7381 for ac_prog in head
7382 do
7383 # Extract the first word of "$ac_prog", so it can be a program name with args.
7384 set dummy $ac_prog; ac_word=$2
7385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7386 $as_echo_n "checking for $ac_word... " >&6; }
7387 if ${ac_cv_path_HEAD+:} false; then :
7388 $as_echo_n "(cached) " >&6
7389 else
7390 case $HEAD in
7391 [\\/]* | ?:[\\/]*)
7392 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7393 ;;
7394 *)
7395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7396 for as_dir in $PATH
7397 do
7398 IFS=$as_save_IFS
7399 test -z "$as_dir" && as_dir=.
7400 for ac_exec_ext in '' $ac_executable_extensions; do
7401 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7402 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7403 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7404 break 2
7405 fi
7406 done
7407 done
7408 IFS=$as_save_IFS
7409
7410 ;;
7411 esac
7412 fi
7413 HEAD=$ac_cv_path_HEAD
7414 if test -n "$HEAD"; then
7415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7416 $as_echo "$HEAD" >&6; }
7417 else
7418 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7419 $as_echo "no" >&6; }
7420 fi
7421
7422
7423 test -n "$HEAD" && break
7424 done
7425
7426 else
7427 # If it succeeded, then it was overridden by the user. We will use it
7428 # for the tool.
7429
7430 # First remove it from the list of overridden variables, so we can test
7431 # for unknown variables in the end.
7432 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7433
7434 # Check if the provided tool contains a complete path.
7435 tool_specified="$HEAD"
7436 tool_basename="${tool_specified##*/}"
7437 if test "x$tool_basename" = "x$tool_specified"; then
7438 # A command without a complete path is provided, search $PATH.
7439 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7440 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7441 # Extract the first word of "$tool_basename", so it can be a program name with args.
7442 set dummy $tool_basename; ac_word=$2
7443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7444 $as_echo_n "checking for $ac_word... " >&6; }
7445 if ${ac_cv_path_HEAD+:} false; then :
7446 $as_echo_n "(cached) " >&6
7447 else
7448 case $HEAD in
7449 [\\/]* | ?:[\\/]*)
7450 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7451 ;;
7452 *)
7453 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7454 for as_dir in $PATH
7455 do
7456 IFS=$as_save_IFS
7457 test -z "$as_dir" && as_dir=.
7458 for ac_exec_ext in '' $ac_executable_extensions; do
7459 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7460 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7461 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7462 break 2
7463 fi
7464 done
7465 done
7466 IFS=$as_save_IFS
7467
7468 ;;
7469 esac
7470 fi
7471 HEAD=$ac_cv_path_HEAD
7472 if test -n "$HEAD"; then
7473 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7474 $as_echo "$HEAD" >&6; }
7475 else
7476 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7477 $as_echo "no" >&6; }
7478 fi
7479
7480
7481 if test "x$HEAD" = x; then
7482 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7483 fi
7484 else
7485 # Otherwise we believe it is a complete path. Use it as it is.
7486 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7487 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7489 $as_echo_n "checking for HEAD... " >&6; }
7490 if test ! -x "$tool_specified"; then
7491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7492 $as_echo "not found" >&6; }
7493 as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7494 fi
7495 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7496 $as_echo "$tool_specified" >&6; }
7497 fi
7498 fi
7499 fi
7500
7501
7502
7503 if test "x$HEAD" = x; then
7504 as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7505 fi
7506
7507
7508
7509
7510
7511 # Publish this variable in the help.
7512
7513
7514 if test "x$LN" = x; then
7515 # The variable is not set by user, try to locate tool using the code snippet
7516 for ac_prog in ln
7517 do
7518 # Extract the first word of "$ac_prog", so it can be a program name with args.
7519 set dummy $ac_prog; ac_word=$2
7520 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7521 $as_echo_n "checking for $ac_word... " >&6; }
7522 if ${ac_cv_path_LN+:} false; then :
7523 $as_echo_n "(cached) " >&6
7524 else
7525 case $LN in
7526 [\\/]* | ?:[\\/]*)
7527 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7528 ;;
7529 *)
7530 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7531 for as_dir in $PATH
7532 do
7533 IFS=$as_save_IFS
7534 test -z "$as_dir" && as_dir=.
7535 for ac_exec_ext in '' $ac_executable_extensions; do
7536 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7537 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7538 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7539 break 2
7540 fi
7541 done
7542 done
7543 IFS=$as_save_IFS
7544
7545 ;;
7546 esac
7547 fi
7548 LN=$ac_cv_path_LN
7549 if test -n "$LN"; then
7550 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7551 $as_echo "$LN" >&6; }
7552 else
7553 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7554 $as_echo "no" >&6; }
7555 fi
7556
7557
7558 test -n "$LN" && break
7559 done
7560
7561 else
7562 # The variable is set, but is it from the command line or the environment?
7563
7564 # Try to remove the string !LN! from our list.
7565 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7566 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7567 # If it failed, the variable was not from the command line. Ignore it,
7568 # but warn the user (except for BASH, which is always set by the calling BASH).
7569 if test "xLN" != xBASH; then
7570 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7571 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7572 fi
7573 # Try to locate tool using the code snippet
7574 for ac_prog in ln
7575 do
7576 # Extract the first word of "$ac_prog", so it can be a program name with args.
7577 set dummy $ac_prog; ac_word=$2
7578 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7579 $as_echo_n "checking for $ac_word... " >&6; }
7580 if ${ac_cv_path_LN+:} false; then :
7581 $as_echo_n "(cached) " >&6
7582 else
7583 case $LN in
7584 [\\/]* | ?:[\\/]*)
7585 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7586 ;;
7587 *)
7588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7589 for as_dir in $PATH
7590 do
7591 IFS=$as_save_IFS
7592 test -z "$as_dir" && as_dir=.
7593 for ac_exec_ext in '' $ac_executable_extensions; do
7594 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7595 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7596 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7597 break 2
7598 fi
7599 done
7600 done
7601 IFS=$as_save_IFS
7602
7603 ;;
7604 esac
7605 fi
7606 LN=$ac_cv_path_LN
7607 if test -n "$LN"; then
7608 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7609 $as_echo "$LN" >&6; }
7610 else
7611 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7612 $as_echo "no" >&6; }
7613 fi
7614
7615
7616 test -n "$LN" && break
7617 done
7618
7619 else
7620 # If it succeeded, then it was overridden by the user. We will use it
7621 # for the tool.
7622
7623 # First remove it from the list of overridden variables, so we can test
7624 # for unknown variables in the end.
7625 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7626
7627 # Check if the provided tool contains a complete path.
7628 tool_specified="$LN"
7629 tool_basename="${tool_specified##*/}"
7630 if test "x$tool_basename" = "x$tool_specified"; then
7631 # A command without a complete path is provided, search $PATH.
7632 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7633 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7634 # Extract the first word of "$tool_basename", so it can be a program name with args.
7635 set dummy $tool_basename; ac_word=$2
7636 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7637 $as_echo_n "checking for $ac_word... " >&6; }
7638 if ${ac_cv_path_LN+:} false; then :
7639 $as_echo_n "(cached) " >&6
7640 else
7641 case $LN in
7642 [\\/]* | ?:[\\/]*)
7643 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7644 ;;
7645 *)
7646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7647 for as_dir in $PATH
7648 do
7649 IFS=$as_save_IFS
7650 test -z "$as_dir" && as_dir=.
7651 for ac_exec_ext in '' $ac_executable_extensions; do
7652 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7653 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7654 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7655 break 2
7656 fi
7657 done
7658 done
7659 IFS=$as_save_IFS
7660
7661 ;;
7662 esac
7663 fi
7664 LN=$ac_cv_path_LN
7665 if test -n "$LN"; then
7666 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7667 $as_echo "$LN" >&6; }
7668 else
7669 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7670 $as_echo "no" >&6; }
7671 fi
7672
7673
7674 if test "x$LN" = x; then
7675 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7676 fi
7677 else
7678 # Otherwise we believe it is a complete path. Use it as it is.
7679 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7680 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7681 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7682 $as_echo_n "checking for LN... " >&6; }
7683 if test ! -x "$tool_specified"; then
7684 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7685 $as_echo "not found" >&6; }
7686 as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7687 fi
7688 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7689 $as_echo "$tool_specified" >&6; }
7690 fi
7691 fi
7692 fi
7693
7694
7695
7696 if test "x$LN" = x; then
7697 as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7698 fi
7699
7700
7701
7702
7703
7704 # Publish this variable in the help.
7705
7706
7707 if test "x$LS" = x; then
7708 # The variable is not set by user, try to locate tool using the code snippet
7709 for ac_prog in ls
7710 do
7711 # Extract the first word of "$ac_prog", so it can be a program name with args.
7712 set dummy $ac_prog; ac_word=$2
7713 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7714 $as_echo_n "checking for $ac_word... " >&6; }
7715 if ${ac_cv_path_LS+:} false; then :
7716 $as_echo_n "(cached) " >&6
7717 else
7718 case $LS in
7719 [\\/]* | ?:[\\/]*)
7720 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7721 ;;
7722 *)
7723 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7724 for as_dir in $PATH
7725 do
7726 IFS=$as_save_IFS
7727 test -z "$as_dir" && as_dir=.
7728 for ac_exec_ext in '' $ac_executable_extensions; do
7729 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7730 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7731 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7732 break 2
7733 fi
7734 done
7735 done
7736 IFS=$as_save_IFS
7737
7738 ;;
7739 esac
7740 fi
7741 LS=$ac_cv_path_LS
7742 if test -n "$LS"; then
7743 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7744 $as_echo "$LS" >&6; }
7745 else
7746 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7747 $as_echo "no" >&6; }
7748 fi
7749
7750
7751 test -n "$LS" && break
7752 done
7753
7754 else
7755 # The variable is set, but is it from the command line or the environment?
7756
7757 # Try to remove the string !LS! from our list.
7758 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7759 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7760 # If it failed, the variable was not from the command line. Ignore it,
7761 # but warn the user (except for BASH, which is always set by the calling BASH).
7762 if test "xLS" != xBASH; then
7763 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7764 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7765 fi
7766 # Try to locate tool using the code snippet
7767 for ac_prog in ls
7768 do
7769 # Extract the first word of "$ac_prog", so it can be a program name with args.
7770 set dummy $ac_prog; ac_word=$2
7771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7772 $as_echo_n "checking for $ac_word... " >&6; }
7773 if ${ac_cv_path_LS+:} false; then :
7774 $as_echo_n "(cached) " >&6
7775 else
7776 case $LS in
7777 [\\/]* | ?:[\\/]*)
7778 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7779 ;;
7780 *)
7781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7782 for as_dir in $PATH
7783 do
7784 IFS=$as_save_IFS
7785 test -z "$as_dir" && as_dir=.
7786 for ac_exec_ext in '' $ac_executable_extensions; do
7787 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7788 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7789 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7790 break 2
7791 fi
7792 done
7793 done
7794 IFS=$as_save_IFS
7795
7796 ;;
7797 esac
7798 fi
7799 LS=$ac_cv_path_LS
7800 if test -n "$LS"; then
7801 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7802 $as_echo "$LS" >&6; }
7803 else
7804 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7805 $as_echo "no" >&6; }
7806 fi
7807
7808
7809 test -n "$LS" && break
7810 done
7811
7812 else
7813 # If it succeeded, then it was overridden by the user. We will use it
7814 # for the tool.
7815
7816 # First remove it from the list of overridden variables, so we can test
7817 # for unknown variables in the end.
7818 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7819
7820 # Check if the provided tool contains a complete path.
7821 tool_specified="$LS"
7822 tool_basename="${tool_specified##*/}"
7823 if test "x$tool_basename" = "x$tool_specified"; then
7824 # A command without a complete path is provided, search $PATH.
7825 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7826 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7827 # Extract the first word of "$tool_basename", so it can be a program name with args.
7828 set dummy $tool_basename; ac_word=$2
7829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7830 $as_echo_n "checking for $ac_word... " >&6; }
7831 if ${ac_cv_path_LS+:} false; then :
7832 $as_echo_n "(cached) " >&6
7833 else
7834 case $LS in
7835 [\\/]* | ?:[\\/]*)
7836 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7837 ;;
7838 *)
7839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7840 for as_dir in $PATH
7841 do
7842 IFS=$as_save_IFS
7843 test -z "$as_dir" && as_dir=.
7844 for ac_exec_ext in '' $ac_executable_extensions; do
7845 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7846 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7847 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7848 break 2
7849 fi
7850 done
7851 done
7852 IFS=$as_save_IFS
7853
7854 ;;
7855 esac
7856 fi
7857 LS=$ac_cv_path_LS
7858 if test -n "$LS"; then
7859 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7860 $as_echo "$LS" >&6; }
7861 else
7862 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7863 $as_echo "no" >&6; }
7864 fi
7865
7866
7867 if test "x$LS" = x; then
7868 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7869 fi
7870 else
7871 # Otherwise we believe it is a complete path. Use it as it is.
7872 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7873 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7875 $as_echo_n "checking for LS... " >&6; }
7876 if test ! -x "$tool_specified"; then
7877 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7878 $as_echo "not found" >&6; }
7879 as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7880 fi
7881 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7882 $as_echo "$tool_specified" >&6; }
7883 fi
7884 fi
7885 fi
7886
7887
7888
7889 if test "x$LS" = x; then
7890 as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7891 fi
7892
7893
7894
7895
7896
7897 # Publish this variable in the help.
7898
7899
7900 if test "x$MKDIR" = x; then
7901 # The variable is not set by user, try to locate tool using the code snippet
7902 for ac_prog in mkdir
7903 do
7904 # Extract the first word of "$ac_prog", so it can be a program name with args.
7905 set dummy $ac_prog; ac_word=$2
7906 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7907 $as_echo_n "checking for $ac_word... " >&6; }
7908 if ${ac_cv_path_MKDIR+:} false; then :
7909 $as_echo_n "(cached) " >&6
7910 else
7911 case $MKDIR in
7912 [\\/]* | ?:[\\/]*)
7913 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7914 ;;
7915 *)
7916 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7917 for as_dir in $PATH
7918 do
7919 IFS=$as_save_IFS
7920 test -z "$as_dir" && as_dir=.
7921 for ac_exec_ext in '' $ac_executable_extensions; do
7922 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7923 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7924 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7925 break 2
7926 fi
7927 done
7928 done
7929 IFS=$as_save_IFS
7930
7931 ;;
7932 esac
7933 fi
7934 MKDIR=$ac_cv_path_MKDIR
7935 if test -n "$MKDIR"; then
7936 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7937 $as_echo "$MKDIR" >&6; }
7938 else
7939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7940 $as_echo "no" >&6; }
7941 fi
7942
7943
7944 test -n "$MKDIR" && break
7945 done
7946
7947 else
7948 # The variable is set, but is it from the command line or the environment?
7949
7950 # Try to remove the string !MKDIR! from our list.
7951 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7952 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7953 # If it failed, the variable was not from the command line. Ignore it,
7954 # but warn the user (except for BASH, which is always set by the calling BASH).
7955 if test "xMKDIR" != xBASH; then
7956 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7957 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7958 fi
7959 # Try to locate tool using the code snippet
7960 for ac_prog in mkdir
7961 do
7962 # Extract the first word of "$ac_prog", so it can be a program name with args.
7963 set dummy $ac_prog; ac_word=$2
7964 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7965 $as_echo_n "checking for $ac_word... " >&6; }
7966 if ${ac_cv_path_MKDIR+:} false; then :
7967 $as_echo_n "(cached) " >&6
7968 else
7969 case $MKDIR in
7970 [\\/]* | ?:[\\/]*)
7971 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7972 ;;
7973 *)
7974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7975 for as_dir in $PATH
7976 do
7977 IFS=$as_save_IFS
7978 test -z "$as_dir" && as_dir=.
7979 for ac_exec_ext in '' $ac_executable_extensions; do
7980 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7981 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7982 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7983 break 2
7984 fi
7985 done
7986 done
7987 IFS=$as_save_IFS
7988
7989 ;;
7990 esac
7991 fi
7992 MKDIR=$ac_cv_path_MKDIR
7993 if test -n "$MKDIR"; then
7994 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7995 $as_echo "$MKDIR" >&6; }
7996 else
7997 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7998 $as_echo "no" >&6; }
7999 fi
8000
8001
8002 test -n "$MKDIR" && break
8003 done
8004
8005 else
8006 # If it succeeded, then it was overridden by the user. We will use it
8007 # for the tool.
8008
8009 # First remove it from the list of overridden variables, so we can test
8010 # for unknown variables in the end.
8011 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8012
8013 # Check if the provided tool contains a complete path.
8014 tool_specified="$MKDIR"
8015 tool_basename="${tool_specified##*/}"
8016 if test "x$tool_basename" = "x$tool_specified"; then
8017 # A command without a complete path is provided, search $PATH.
8018 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8019 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8020 # Extract the first word of "$tool_basename", so it can be a program name with args.
8021 set dummy $tool_basename; ac_word=$2
8022 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8023 $as_echo_n "checking for $ac_word... " >&6; }
8024 if ${ac_cv_path_MKDIR+:} false; then :
8025 $as_echo_n "(cached) " >&6
8026 else
8027 case $MKDIR in
8028 [\\/]* | ?:[\\/]*)
8029 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8030 ;;
8031 *)
8032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8033 for as_dir in $PATH
8034 do
8035 IFS=$as_save_IFS
8036 test -z "$as_dir" && as_dir=.
8037 for ac_exec_ext in '' $ac_executable_extensions; do
8038 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8039 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8040 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8041 break 2
8042 fi
8043 done
8044 done
8045 IFS=$as_save_IFS
8046
8047 ;;
8048 esac
8049 fi
8050 MKDIR=$ac_cv_path_MKDIR
8051 if test -n "$MKDIR"; then
8052 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8053 $as_echo "$MKDIR" >&6; }
8054 else
8055 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8056 $as_echo "no" >&6; }
8057 fi
8058
8059
8060 if test "x$MKDIR" = x; then
8061 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8062 fi
8063 else
8064 # Otherwise we believe it is a complete path. Use it as it is.
8065 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8066 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8067 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8068 $as_echo_n "checking for MKDIR... " >&6; }
8069 if test ! -x "$tool_specified"; then
8070 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8071 $as_echo "not found" >&6; }
8072 as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8073 fi
8074 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8075 $as_echo "$tool_specified" >&6; }
8076 fi
8077 fi
8078 fi
8079
8080
8081
8082 if test "x$MKDIR" = x; then
8083 as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8084 fi
8085
8086
8087
8088
8089
8090 # Publish this variable in the help.
8091
8092
8093 if test "x$MKTEMP" = x; then
8094 # The variable is not set by user, try to locate tool using the code snippet
8095 for ac_prog in mktemp
8096 do
8097 # Extract the first word of "$ac_prog", so it can be a program name with args.
8098 set dummy $ac_prog; ac_word=$2
8099 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8100 $as_echo_n "checking for $ac_word... " >&6; }
8101 if ${ac_cv_path_MKTEMP+:} false; then :
8102 $as_echo_n "(cached) " >&6
8103 else
8104 case $MKTEMP in
8105 [\\/]* | ?:[\\/]*)
8106 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8107 ;;
8108 *)
8109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8110 for as_dir in $PATH
8111 do
8112 IFS=$as_save_IFS
8113 test -z "$as_dir" && as_dir=.
8114 for ac_exec_ext in '' $ac_executable_extensions; do
8115 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8116 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8117 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8118 break 2
8119 fi
8120 done
8121 done
8122 IFS=$as_save_IFS
8123
8124 ;;
8125 esac
8126 fi
8127 MKTEMP=$ac_cv_path_MKTEMP
8128 if test -n "$MKTEMP"; then
8129 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8130 $as_echo "$MKTEMP" >&6; }
8131 else
8132 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8133 $as_echo "no" >&6; }
8134 fi
8135
8136
8137 test -n "$MKTEMP" && break
8138 done
8139
8140 else
8141 # The variable is set, but is it from the command line or the environment?
8142
8143 # Try to remove the string !MKTEMP! from our list.
8144 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8145 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8146 # If it failed, the variable was not from the command line. Ignore it,
8147 # but warn the user (except for BASH, which is always set by the calling BASH).
8148 if test "xMKTEMP" != xBASH; then
8149 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8150 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8151 fi
8152 # Try to locate tool using the code snippet
8153 for ac_prog in mktemp
8154 do
8155 # Extract the first word of "$ac_prog", so it can be a program name with args.
8156 set dummy $ac_prog; ac_word=$2
8157 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8158 $as_echo_n "checking for $ac_word... " >&6; }
8159 if ${ac_cv_path_MKTEMP+:} false; then :
8160 $as_echo_n "(cached) " >&6
8161 else
8162 case $MKTEMP in
8163 [\\/]* | ?:[\\/]*)
8164 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8165 ;;
8166 *)
8167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8168 for as_dir in $PATH
8169 do
8170 IFS=$as_save_IFS
8171 test -z "$as_dir" && as_dir=.
8172 for ac_exec_ext in '' $ac_executable_extensions; do
8173 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8174 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8175 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8176 break 2
8177 fi
8178 done
8179 done
8180 IFS=$as_save_IFS
8181
8182 ;;
8183 esac
8184 fi
8185 MKTEMP=$ac_cv_path_MKTEMP
8186 if test -n "$MKTEMP"; then
8187 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8188 $as_echo "$MKTEMP" >&6; }
8189 else
8190 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8191 $as_echo "no" >&6; }
8192 fi
8193
8194
8195 test -n "$MKTEMP" && break
8196 done
8197
8198 else
8199 # If it succeeded, then it was overridden by the user. We will use it
8200 # for the tool.
8201
8202 # First remove it from the list of overridden variables, so we can test
8203 # for unknown variables in the end.
8204 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8205
8206 # Check if the provided tool contains a complete path.
8207 tool_specified="$MKTEMP"
8208 tool_basename="${tool_specified##*/}"
8209 if test "x$tool_basename" = "x$tool_specified"; then
8210 # A command without a complete path is provided, search $PATH.
8211 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8212 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8213 # Extract the first word of "$tool_basename", so it can be a program name with args.
8214 set dummy $tool_basename; ac_word=$2
8215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8216 $as_echo_n "checking for $ac_word... " >&6; }
8217 if ${ac_cv_path_MKTEMP+:} false; then :
8218 $as_echo_n "(cached) " >&6
8219 else
8220 case $MKTEMP in
8221 [\\/]* | ?:[\\/]*)
8222 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8223 ;;
8224 *)
8225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8226 for as_dir in $PATH
8227 do
8228 IFS=$as_save_IFS
8229 test -z "$as_dir" && as_dir=.
8230 for ac_exec_ext in '' $ac_executable_extensions; do
8231 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8232 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8233 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8234 break 2
8235 fi
8236 done
8237 done
8238 IFS=$as_save_IFS
8239
8240 ;;
8241 esac
8242 fi
8243 MKTEMP=$ac_cv_path_MKTEMP
8244 if test -n "$MKTEMP"; then
8245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8246 $as_echo "$MKTEMP" >&6; }
8247 else
8248 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8249 $as_echo "no" >&6; }
8250 fi
8251
8252
8253 if test "x$MKTEMP" = x; then
8254 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8255 fi
8256 else
8257 # Otherwise we believe it is a complete path. Use it as it is.
8258 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8259 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8260 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8261 $as_echo_n "checking for MKTEMP... " >&6; }
8262 if test ! -x "$tool_specified"; then
8263 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8264 $as_echo "not found" >&6; }
8265 as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8266 fi
8267 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8268 $as_echo "$tool_specified" >&6; }
8269 fi
8270 fi
8271 fi
8272
8273
8274
8275 if test "x$MKTEMP" = x; then
8276 as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8277 fi
8278
8279
8280
8281
8282
8283 # Publish this variable in the help.
8284
8285
8286 if test "x$MV" = x; then
8287 # The variable is not set by user, try to locate tool using the code snippet
8288 for ac_prog in mv
8289 do
8290 # Extract the first word of "$ac_prog", so it can be a program name with args.
8291 set dummy $ac_prog; ac_word=$2
8292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8293 $as_echo_n "checking for $ac_word... " >&6; }
8294 if ${ac_cv_path_MV+:} false; then :
8295 $as_echo_n "(cached) " >&6
8296 else
8297 case $MV in
8298 [\\/]* | ?:[\\/]*)
8299 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8300 ;;
8301 *)
8302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8303 for as_dir in $PATH
8304 do
8305 IFS=$as_save_IFS
8306 test -z "$as_dir" && as_dir=.
8307 for ac_exec_ext in '' $ac_executable_extensions; do
8308 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8309 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8310 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8311 break 2
8312 fi
8313 done
8314 done
8315 IFS=$as_save_IFS
8316
8317 ;;
8318 esac
8319 fi
8320 MV=$ac_cv_path_MV
8321 if test -n "$MV"; then
8322 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8323 $as_echo "$MV" >&6; }
8324 else
8325 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8326 $as_echo "no" >&6; }
8327 fi
8328
8329
8330 test -n "$MV" && break
8331 done
8332
8333 else
8334 # The variable is set, but is it from the command line or the environment?
8335
8336 # Try to remove the string !MV! from our list.
8337 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8338 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8339 # If it failed, the variable was not from the command line. Ignore it,
8340 # but warn the user (except for BASH, which is always set by the calling BASH).
8341 if test "xMV" != xBASH; then
8342 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8343 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8344 fi
8345 # Try to locate tool using the code snippet
8346 for ac_prog in mv
8347 do
8348 # Extract the first word of "$ac_prog", so it can be a program name with args.
8349 set dummy $ac_prog; ac_word=$2
8350 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8351 $as_echo_n "checking for $ac_word... " >&6; }
8352 if ${ac_cv_path_MV+:} false; then :
8353 $as_echo_n "(cached) " >&6
8354 else
8355 case $MV in
8356 [\\/]* | ?:[\\/]*)
8357 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8358 ;;
8359 *)
8360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8361 for as_dir in $PATH
8362 do
8363 IFS=$as_save_IFS
8364 test -z "$as_dir" && as_dir=.
8365 for ac_exec_ext in '' $ac_executable_extensions; do
8366 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8367 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8368 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8369 break 2
8370 fi
8371 done
8372 done
8373 IFS=$as_save_IFS
8374
8375 ;;
8376 esac
8377 fi
8378 MV=$ac_cv_path_MV
8379 if test -n "$MV"; then
8380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8381 $as_echo "$MV" >&6; }
8382 else
8383 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8384 $as_echo "no" >&6; }
8385 fi
8386
8387
8388 test -n "$MV" && break
8389 done
8390
8391 else
8392 # If it succeeded, then it was overridden by the user. We will use it
8393 # for the tool.
8394
8395 # First remove it from the list of overridden variables, so we can test
8396 # for unknown variables in the end.
8397 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8398
8399 # Check if the provided tool contains a complete path.
8400 tool_specified="$MV"
8401 tool_basename="${tool_specified##*/}"
8402 if test "x$tool_basename" = "x$tool_specified"; then
8403 # A command without a complete path is provided, search $PATH.
8404 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8405 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8406 # Extract the first word of "$tool_basename", so it can be a program name with args.
8407 set dummy $tool_basename; ac_word=$2
8408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8409 $as_echo_n "checking for $ac_word... " >&6; }
8410 if ${ac_cv_path_MV+:} false; then :
8411 $as_echo_n "(cached) " >&6
8412 else
8413 case $MV in
8414 [\\/]* | ?:[\\/]*)
8415 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8416 ;;
8417 *)
8418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8419 for as_dir in $PATH
8420 do
8421 IFS=$as_save_IFS
8422 test -z "$as_dir" && as_dir=.
8423 for ac_exec_ext in '' $ac_executable_extensions; do
8424 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8425 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8426 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8427 break 2
8428 fi
8429 done
8430 done
8431 IFS=$as_save_IFS
8432
8433 ;;
8434 esac
8435 fi
8436 MV=$ac_cv_path_MV
8437 if test -n "$MV"; then
8438 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8439 $as_echo "$MV" >&6; }
8440 else
8441 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8442 $as_echo "no" >&6; }
8443 fi
8444
8445
8446 if test "x$MV" = x; then
8447 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8448 fi
8449 else
8450 # Otherwise we believe it is a complete path. Use it as it is.
8451 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8452 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8453 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8454 $as_echo_n "checking for MV... " >&6; }
8455 if test ! -x "$tool_specified"; then
8456 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8457 $as_echo "not found" >&6; }
8458 as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8459 fi
8460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8461 $as_echo "$tool_specified" >&6; }
8462 fi
8463 fi
8464 fi
8465
8466
8467
8468 if test "x$MV" = x; then
8469 as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8470 fi
8471
8472
8473
8474
8475
8476 # Publish this variable in the help.
8477
8478
8479 if test "x$NAWK" = x; then
8480 # The variable is not set by user, try to locate tool using the code snippet
8481 for ac_prog in nawk gawk awk
8482 do
8483 # Extract the first word of "$ac_prog", so it can be a program name with args.
8484 set dummy $ac_prog; ac_word=$2
8485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8486 $as_echo_n "checking for $ac_word... " >&6; }
8487 if ${ac_cv_path_NAWK+:} false; then :
8488 $as_echo_n "(cached) " >&6
8489 else
8490 case $NAWK in
8491 [\\/]* | ?:[\\/]*)
8492 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8493 ;;
8494 *)
8495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8496 for as_dir in $PATH
8497 do
8498 IFS=$as_save_IFS
8499 test -z "$as_dir" && as_dir=.
8500 for ac_exec_ext in '' $ac_executable_extensions; do
8501 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8502 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8503 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8504 break 2
8505 fi
8506 done
8507 done
8508 IFS=$as_save_IFS
8509
8510 ;;
8511 esac
8512 fi
8513 NAWK=$ac_cv_path_NAWK
8514 if test -n "$NAWK"; then
8515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8516 $as_echo "$NAWK" >&6; }
8517 else
8518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8519 $as_echo "no" >&6; }
8520 fi
8521
8522
8523 test -n "$NAWK" && break
8524 done
8525
8526 else
8527 # The variable is set, but is it from the command line or the environment?
8528
8529 # Try to remove the string !NAWK! from our list.
8530 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8531 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8532 # If it failed, the variable was not from the command line. Ignore it,
8533 # but warn the user (except for BASH, which is always set by the calling BASH).
8534 if test "xNAWK" != xBASH; then
8535 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8536 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8537 fi
8538 # Try to locate tool using the code snippet
8539 for ac_prog in nawk gawk awk
8540 do
8541 # Extract the first word of "$ac_prog", so it can be a program name with args.
8542 set dummy $ac_prog; ac_word=$2
8543 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8544 $as_echo_n "checking for $ac_word... " >&6; }
8545 if ${ac_cv_path_NAWK+:} false; then :
8546 $as_echo_n "(cached) " >&6
8547 else
8548 case $NAWK in
8549 [\\/]* | ?:[\\/]*)
8550 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8551 ;;
8552 *)
8553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8554 for as_dir in $PATH
8555 do
8556 IFS=$as_save_IFS
8557 test -z "$as_dir" && as_dir=.
8558 for ac_exec_ext in '' $ac_executable_extensions; do
8559 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8560 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8561 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8562 break 2
8563 fi
8564 done
8565 done
8566 IFS=$as_save_IFS
8567
8568 ;;
8569 esac
8570 fi
8571 NAWK=$ac_cv_path_NAWK
8572 if test -n "$NAWK"; then
8573 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8574 $as_echo "$NAWK" >&6; }
8575 else
8576 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8577 $as_echo "no" >&6; }
8578 fi
8579
8580
8581 test -n "$NAWK" && break
8582 done
8583
8584 else
8585 # If it succeeded, then it was overridden by the user. We will use it
8586 # for the tool.
8587
8588 # First remove it from the list of overridden variables, so we can test
8589 # for unknown variables in the end.
8590 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8591
8592 # Check if the provided tool contains a complete path.
8593 tool_specified="$NAWK"
8594 tool_basename="${tool_specified##*/}"
8595 if test "x$tool_basename" = "x$tool_specified"; then
8596 # A command without a complete path is provided, search $PATH.
8597 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8598 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8599 # Extract the first word of "$tool_basename", so it can be a program name with args.
8600 set dummy $tool_basename; ac_word=$2
8601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8602 $as_echo_n "checking for $ac_word... " >&6; }
8603 if ${ac_cv_path_NAWK+:} false; then :
8604 $as_echo_n "(cached) " >&6
8605 else
8606 case $NAWK in
8607 [\\/]* | ?:[\\/]*)
8608 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8609 ;;
8610 *)
8611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8612 for as_dir in $PATH
8613 do
8614 IFS=$as_save_IFS
8615 test -z "$as_dir" && as_dir=.
8616 for ac_exec_ext in '' $ac_executable_extensions; do
8617 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8618 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8619 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8620 break 2
8621 fi
8622 done
8623 done
8624 IFS=$as_save_IFS
8625
8626 ;;
8627 esac
8628 fi
8629 NAWK=$ac_cv_path_NAWK
8630 if test -n "$NAWK"; then
8631 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8632 $as_echo "$NAWK" >&6; }
8633 else
8634 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8635 $as_echo "no" >&6; }
8636 fi
8637
8638
8639 if test "x$NAWK" = x; then
8640 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8641 fi
8642 else
8643 # Otherwise we believe it is a complete path. Use it as it is.
8644 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8645 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8646 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8647 $as_echo_n "checking for NAWK... " >&6; }
8648 if test ! -x "$tool_specified"; then
8649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8650 $as_echo "not found" >&6; }
8651 as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8652 fi
8653 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8654 $as_echo "$tool_specified" >&6; }
8655 fi
8656 fi
8657 fi
8658
8659
8660
8661 if test "x$NAWK" = x; then
8662 as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8663 fi
8664
8665
8666
8667
8668
8669 # Publish this variable in the help.
8670
8671
8672 if test "x$PRINTF" = x; then
8673 # The variable is not set by user, try to locate tool using the code snippet
8674 for ac_prog in printf
8675 do
8676 # Extract the first word of "$ac_prog", so it can be a program name with args.
8677 set dummy $ac_prog; ac_word=$2
8678 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8679 $as_echo_n "checking for $ac_word... " >&6; }
8680 if ${ac_cv_path_PRINTF+:} false; then :
8681 $as_echo_n "(cached) " >&6
8682 else
8683 case $PRINTF in
8684 [\\/]* | ?:[\\/]*)
8685 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8686 ;;
8687 *)
8688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8689 for as_dir in $PATH
8690 do
8691 IFS=$as_save_IFS
8692 test -z "$as_dir" && as_dir=.
8693 for ac_exec_ext in '' $ac_executable_extensions; do
8694 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8695 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8696 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8697 break 2
8698 fi
8699 done
8700 done
8701 IFS=$as_save_IFS
8702
8703 ;;
8704 esac
8705 fi
8706 PRINTF=$ac_cv_path_PRINTF
8707 if test -n "$PRINTF"; then
8708 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8709 $as_echo "$PRINTF" >&6; }
8710 else
8711 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8712 $as_echo "no" >&6; }
8713 fi
8714
8715
8716 test -n "$PRINTF" && break
8717 done
8718
8719 else
8720 # The variable is set, but is it from the command line or the environment?
8721
8722 # Try to remove the string !PRINTF! from our list.
8723 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8724 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8725 # If it failed, the variable was not from the command line. Ignore it,
8726 # but warn the user (except for BASH, which is always set by the calling BASH).
8727 if test "xPRINTF" != xBASH; then
8728 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8729 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8730 fi
8731 # Try to locate tool using the code snippet
8732 for ac_prog in printf
8733 do
8734 # Extract the first word of "$ac_prog", so it can be a program name with args.
8735 set dummy $ac_prog; ac_word=$2
8736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8737 $as_echo_n "checking for $ac_word... " >&6; }
8738 if ${ac_cv_path_PRINTF+:} false; then :
8739 $as_echo_n "(cached) " >&6
8740 else
8741 case $PRINTF in
8742 [\\/]* | ?:[\\/]*)
8743 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8744 ;;
8745 *)
8746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8747 for as_dir in $PATH
8748 do
8749 IFS=$as_save_IFS
8750 test -z "$as_dir" && as_dir=.
8751 for ac_exec_ext in '' $ac_executable_extensions; do
8752 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8753 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8754 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8755 break 2
8756 fi
8757 done
8758 done
8759 IFS=$as_save_IFS
8760
8761 ;;
8762 esac
8763 fi
8764 PRINTF=$ac_cv_path_PRINTF
8765 if test -n "$PRINTF"; then
8766 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8767 $as_echo "$PRINTF" >&6; }
8768 else
8769 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8770 $as_echo "no" >&6; }
8771 fi
8772
8773
8774 test -n "$PRINTF" && break
8775 done
8776
8777 else
8778 # If it succeeded, then it was overridden by the user. We will use it
8779 # for the tool.
8780
8781 # First remove it from the list of overridden variables, so we can test
8782 # for unknown variables in the end.
8783 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8784
8785 # Check if the provided tool contains a complete path.
8786 tool_specified="$PRINTF"
8787 tool_basename="${tool_specified##*/}"
8788 if test "x$tool_basename" = "x$tool_specified"; then
8789 # A command without a complete path is provided, search $PATH.
8790 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8791 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8792 # Extract the first word of "$tool_basename", so it can be a program name with args.
8793 set dummy $tool_basename; ac_word=$2
8794 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8795 $as_echo_n "checking for $ac_word... " >&6; }
8796 if ${ac_cv_path_PRINTF+:} false; then :
8797 $as_echo_n "(cached) " >&6
8798 else
8799 case $PRINTF in
8800 [\\/]* | ?:[\\/]*)
8801 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8802 ;;
8803 *)
8804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8805 for as_dir in $PATH
8806 do
8807 IFS=$as_save_IFS
8808 test -z "$as_dir" && as_dir=.
8809 for ac_exec_ext in '' $ac_executable_extensions; do
8810 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8811 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8812 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8813 break 2
8814 fi
8815 done
8816 done
8817 IFS=$as_save_IFS
8818
8819 ;;
8820 esac
8821 fi
8822 PRINTF=$ac_cv_path_PRINTF
8823 if test -n "$PRINTF"; then
8824 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8825 $as_echo "$PRINTF" >&6; }
8826 else
8827 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8828 $as_echo "no" >&6; }
8829 fi
8830
8831
8832 if test "x$PRINTF" = x; then
8833 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8834 fi
8835 else
8836 # Otherwise we believe it is a complete path. Use it as it is.
8837 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8838 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8840 $as_echo_n "checking for PRINTF... " >&6; }
8841 if test ! -x "$tool_specified"; then
8842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8843 $as_echo "not found" >&6; }
8844 as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8845 fi
8846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8847 $as_echo "$tool_specified" >&6; }
8848 fi
8849 fi
8850 fi
8851
8852
8853
8854 if test "x$PRINTF" = x; then
8855 as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8856 fi
8857
8858
8859
8860
8861
8862 # Publish this variable in the help.
8863
8864
8865 if test "x$RM" = x; then
8866 # The variable is not set by user, try to locate tool using the code snippet
8867 for ac_prog in rm
8868 do
8869 # Extract the first word of "$ac_prog", so it can be a program name with args.
8870 set dummy $ac_prog; ac_word=$2
8871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8872 $as_echo_n "checking for $ac_word... " >&6; }
8873 if ${ac_cv_path_RM+:} false; then :
8874 $as_echo_n "(cached) " >&6
8875 else
8876 case $RM in
8877 [\\/]* | ?:[\\/]*)
8878 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8879 ;;
8880 *)
8881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8882 for as_dir in $PATH
8883 do
8884 IFS=$as_save_IFS
8885 test -z "$as_dir" && as_dir=.
8886 for ac_exec_ext in '' $ac_executable_extensions; do
8887 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8888 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8889 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8890 break 2
8891 fi
8892 done
8893 done
8894 IFS=$as_save_IFS
8895
8896 ;;
8897 esac
8898 fi
8899 RM=$ac_cv_path_RM
8900 if test -n "$RM"; then
8901 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8902 $as_echo "$RM" >&6; }
8903 else
8904 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8905 $as_echo "no" >&6; }
8906 fi
8907
8908
8909 test -n "$RM" && break
8910 done
8911
8912 else
8913 # The variable is set, but is it from the command line or the environment?
8914
8915 # Try to remove the string !RM! from our list.
8916 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8917 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8918 # If it failed, the variable was not from the command line. Ignore it,
8919 # but warn the user (except for BASH, which is always set by the calling BASH).
8920 if test "xRM" != xBASH; then
8921 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8922 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8923 fi
8924 # Try to locate tool using the code snippet
8925 for ac_prog in rm
8926 do
8927 # Extract the first word of "$ac_prog", so it can be a program name with args.
8928 set dummy $ac_prog; ac_word=$2
8929 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8930 $as_echo_n "checking for $ac_word... " >&6; }
8931 if ${ac_cv_path_RM+:} false; then :
8932 $as_echo_n "(cached) " >&6
8933 else
8934 case $RM in
8935 [\\/]* | ?:[\\/]*)
8936 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8937 ;;
8938 *)
8939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8940 for as_dir in $PATH
8941 do
8942 IFS=$as_save_IFS
8943 test -z "$as_dir" && as_dir=.
8944 for ac_exec_ext in '' $ac_executable_extensions; do
8945 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8946 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8947 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8948 break 2
8949 fi
8950 done
8951 done
8952 IFS=$as_save_IFS
8953
8954 ;;
8955 esac
8956 fi
8957 RM=$ac_cv_path_RM
8958 if test -n "$RM"; then
8959 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8960 $as_echo "$RM" >&6; }
8961 else
8962 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8963 $as_echo "no" >&6; }
8964 fi
8965
8966
8967 test -n "$RM" && break
8968 done
8969
8970 else
8971 # If it succeeded, then it was overridden by the user. We will use it
8972 # for the tool.
8973
8974 # First remove it from the list of overridden variables, so we can test
8975 # for unknown variables in the end.
8976 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8977
8978 # Check if the provided tool contains a complete path.
8979 tool_specified="$RM"
8980 tool_basename="${tool_specified##*/}"
8981 if test "x$tool_basename" = "x$tool_specified"; then
8982 # A command without a complete path is provided, search $PATH.
8983 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8984 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8985 # Extract the first word of "$tool_basename", so it can be a program name with args.
8986 set dummy $tool_basename; ac_word=$2
8987 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8988 $as_echo_n "checking for $ac_word... " >&6; }
8989 if ${ac_cv_path_RM+:} false; then :
8990 $as_echo_n "(cached) " >&6
8991 else
8992 case $RM in
8993 [\\/]* | ?:[\\/]*)
8994 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8995 ;;
8996 *)
8997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8998 for as_dir in $PATH
8999 do
9000 IFS=$as_save_IFS
9001 test -z "$as_dir" && as_dir=.
9002 for ac_exec_ext in '' $ac_executable_extensions; do
9003 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9004 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9005 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9006 break 2
9007 fi
9008 done
9009 done
9010 IFS=$as_save_IFS
9011
9012 ;;
9013 esac
9014 fi
9015 RM=$ac_cv_path_RM
9016 if test -n "$RM"; then
9017 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9018 $as_echo "$RM" >&6; }
9019 else
9020 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9021 $as_echo "no" >&6; }
9022 fi
9023
9024
9025 if test "x$RM" = x; then
9026 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9027 fi
9028 else
9029 # Otherwise we believe it is a complete path. Use it as it is.
9030 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9031 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9032 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9033 $as_echo_n "checking for RM... " >&6; }
9034 if test ! -x "$tool_specified"; then
9035 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9036 $as_echo "not found" >&6; }
9037 as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9038 fi
9039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9040 $as_echo "$tool_specified" >&6; }
9041 fi
9042 fi
9043 fi
9044
9045
9046
9047 if test "x$RM" = x; then
9048 as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9049 fi
9050
9051
9052
9053
9054
9055 # Publish this variable in the help.
9056
9057
9058 if test "x$SH" = x; then
9059 # The variable is not set by user, try to locate tool using the code snippet
9060 for ac_prog in sh
9061 do
9062 # Extract the first word of "$ac_prog", so it can be a program name with args.
9063 set dummy $ac_prog; ac_word=$2
9064 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9065 $as_echo_n "checking for $ac_word... " >&6; }
9066 if ${ac_cv_path_SH+:} false; then :
9067 $as_echo_n "(cached) " >&6
9068 else
9069 case $SH in
9070 [\\/]* | ?:[\\/]*)
9071 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9072 ;;
9073 *)
9074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9075 for as_dir in $PATH
9076 do
9077 IFS=$as_save_IFS
9078 test -z "$as_dir" && as_dir=.
9079 for ac_exec_ext in '' $ac_executable_extensions; do
9080 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9081 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9082 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9083 break 2
9084 fi
9085 done
9086 done
9087 IFS=$as_save_IFS
9088
9089 ;;
9090 esac
9091 fi
9092 SH=$ac_cv_path_SH
9093 if test -n "$SH"; then
9094 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9095 $as_echo "$SH" >&6; }
9096 else
9097 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9098 $as_echo "no" >&6; }
9099 fi
9100
9101
9102 test -n "$SH" && break
9103 done
9104
9105 else
9106 # The variable is set, but is it from the command line or the environment?
9107
9108 # Try to remove the string !SH! from our list.
9109 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9110 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9111 # If it failed, the variable was not from the command line. Ignore it,
9112 # but warn the user (except for BASH, which is always set by the calling BASH).
9113 if test "xSH" != xBASH; then
9114 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9115 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9116 fi
9117 # Try to locate tool using the code snippet
9118 for ac_prog in sh
9119 do
9120 # Extract the first word of "$ac_prog", so it can be a program name with args.
9121 set dummy $ac_prog; ac_word=$2
9122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9123 $as_echo_n "checking for $ac_word... " >&6; }
9124 if ${ac_cv_path_SH+:} false; then :
9125 $as_echo_n "(cached) " >&6
9126 else
9127 case $SH in
9128 [\\/]* | ?:[\\/]*)
9129 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9130 ;;
9131 *)
9132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9133 for as_dir in $PATH
9134 do
9135 IFS=$as_save_IFS
9136 test -z "$as_dir" && as_dir=.
9137 for ac_exec_ext in '' $ac_executable_extensions; do
9138 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9139 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9140 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9141 break 2
9142 fi
9143 done
9144 done
9145 IFS=$as_save_IFS
9146
9147 ;;
9148 esac
9149 fi
9150 SH=$ac_cv_path_SH
9151 if test -n "$SH"; then
9152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9153 $as_echo "$SH" >&6; }
9154 else
9155 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9156 $as_echo "no" >&6; }
9157 fi
9158
9159
9160 test -n "$SH" && break
9161 done
9162
9163 else
9164 # If it succeeded, then it was overridden by the user. We will use it
9165 # for the tool.
9166
9167 # First remove it from the list of overridden variables, so we can test
9168 # for unknown variables in the end.
9169 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9170
9171 # Check if the provided tool contains a complete path.
9172 tool_specified="$SH"
9173 tool_basename="${tool_specified##*/}"
9174 if test "x$tool_basename" = "x$tool_specified"; then
9175 # A command without a complete path is provided, search $PATH.
9176 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9177 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9178 # Extract the first word of "$tool_basename", so it can be a program name with args.
9179 set dummy $tool_basename; ac_word=$2
9180 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9181 $as_echo_n "checking for $ac_word... " >&6; }
9182 if ${ac_cv_path_SH+:} false; then :
9183 $as_echo_n "(cached) " >&6
9184 else
9185 case $SH in
9186 [\\/]* | ?:[\\/]*)
9187 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9188 ;;
9189 *)
9190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9191 for as_dir in $PATH
9192 do
9193 IFS=$as_save_IFS
9194 test -z "$as_dir" && as_dir=.
9195 for ac_exec_ext in '' $ac_executable_extensions; do
9196 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9197 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9198 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9199 break 2
9200 fi
9201 done
9202 done
9203 IFS=$as_save_IFS
9204
9205 ;;
9206 esac
9207 fi
9208 SH=$ac_cv_path_SH
9209 if test -n "$SH"; then
9210 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9211 $as_echo "$SH" >&6; }
9212 else
9213 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9214 $as_echo "no" >&6; }
9215 fi
9216
9217
9218 if test "x$SH" = x; then
9219 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9220 fi
9221 else
9222 # Otherwise we believe it is a complete path. Use it as it is.
9223 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9224 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9225 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9226 $as_echo_n "checking for SH... " >&6; }
9227 if test ! -x "$tool_specified"; then
9228 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9229 $as_echo "not found" >&6; }
9230 as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9231 fi
9232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9233 $as_echo "$tool_specified" >&6; }
9234 fi
9235 fi
9236 fi
9237
9238
9239
9240 if test "x$SH" = x; then
9241 as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9242 fi
9243
9244
9245
9246
9247
9248 # Publish this variable in the help.
9249
9250
9251 if test "x$SORT" = x; then
9252 # The variable is not set by user, try to locate tool using the code snippet
9253 for ac_prog in sort
9254 do
9255 # Extract the first word of "$ac_prog", so it can be a program name with args.
9256 set dummy $ac_prog; ac_word=$2
9257 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9258 $as_echo_n "checking for $ac_word... " >&6; }
9259 if ${ac_cv_path_SORT+:} false; then :
9260 $as_echo_n "(cached) " >&6
9261 else
9262 case $SORT in
9263 [\\/]* | ?:[\\/]*)
9264 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9265 ;;
9266 *)
9267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9268 for as_dir in $PATH
9269 do
9270 IFS=$as_save_IFS
9271 test -z "$as_dir" && as_dir=.
9272 for ac_exec_ext in '' $ac_executable_extensions; do
9273 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9274 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9275 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9276 break 2
9277 fi
9278 done
9279 done
9280 IFS=$as_save_IFS
9281
9282 ;;
9283 esac
9284 fi
9285 SORT=$ac_cv_path_SORT
9286 if test -n "$SORT"; then
9287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9288 $as_echo "$SORT" >&6; }
9289 else
9290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9291 $as_echo "no" >&6; }
9292 fi
9293
9294
9295 test -n "$SORT" && break
9296 done
9297
9298 else
9299 # The variable is set, but is it from the command line or the environment?
9300
9301 # Try to remove the string !SORT! from our list.
9302 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9303 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9304 # If it failed, the variable was not from the command line. Ignore it,
9305 # but warn the user (except for BASH, which is always set by the calling BASH).
9306 if test "xSORT" != xBASH; then
9307 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9308 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9309 fi
9310 # Try to locate tool using the code snippet
9311 for ac_prog in sort
9312 do
9313 # Extract the first word of "$ac_prog", so it can be a program name with args.
9314 set dummy $ac_prog; ac_word=$2
9315 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9316 $as_echo_n "checking for $ac_word... " >&6; }
9317 if ${ac_cv_path_SORT+:} false; then :
9318 $as_echo_n "(cached) " >&6
9319 else
9320 case $SORT in
9321 [\\/]* | ?:[\\/]*)
9322 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9323 ;;
9324 *)
9325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9326 for as_dir in $PATH
9327 do
9328 IFS=$as_save_IFS
9329 test -z "$as_dir" && as_dir=.
9330 for ac_exec_ext in '' $ac_executable_extensions; do
9331 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9332 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9333 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9334 break 2
9335 fi
9336 done
9337 done
9338 IFS=$as_save_IFS
9339
9340 ;;
9341 esac
9342 fi
9343 SORT=$ac_cv_path_SORT
9344 if test -n "$SORT"; then
9345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9346 $as_echo "$SORT" >&6; }
9347 else
9348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9349 $as_echo "no" >&6; }
9350 fi
9351
9352
9353 test -n "$SORT" && break
9354 done
9355
9356 else
9357 # If it succeeded, then it was overridden by the user. We will use it
9358 # for the tool.
9359
9360 # First remove it from the list of overridden variables, so we can test
9361 # for unknown variables in the end.
9362 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9363
9364 # Check if the provided tool contains a complete path.
9365 tool_specified="$SORT"
9366 tool_basename="${tool_specified##*/}"
9367 if test "x$tool_basename" = "x$tool_specified"; then
9368 # A command without a complete path is provided, search $PATH.
9369 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9370 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9371 # Extract the first word of "$tool_basename", so it can be a program name with args.
9372 set dummy $tool_basename; ac_word=$2
9373 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9374 $as_echo_n "checking for $ac_word... " >&6; }
9375 if ${ac_cv_path_SORT+:} false; then :
9376 $as_echo_n "(cached) " >&6
9377 else
9378 case $SORT in
9379 [\\/]* | ?:[\\/]*)
9380 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9381 ;;
9382 *)
9383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9384 for as_dir in $PATH
9385 do
9386 IFS=$as_save_IFS
9387 test -z "$as_dir" && as_dir=.
9388 for ac_exec_ext in '' $ac_executable_extensions; do
9389 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9390 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9391 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9392 break 2
9393 fi
9394 done
9395 done
9396 IFS=$as_save_IFS
9397
9398 ;;
9399 esac
9400 fi
9401 SORT=$ac_cv_path_SORT
9402 if test -n "$SORT"; then
9403 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9404 $as_echo "$SORT" >&6; }
9405 else
9406 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9407 $as_echo "no" >&6; }
9408 fi
9409
9410
9411 if test "x$SORT" = x; then
9412 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9413 fi
9414 else
9415 # Otherwise we believe it is a complete path. Use it as it is.
9416 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9417 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9419 $as_echo_n "checking for SORT... " >&6; }
9420 if test ! -x "$tool_specified"; then
9421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9422 $as_echo "not found" >&6; }
9423 as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9424 fi
9425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9426 $as_echo "$tool_specified" >&6; }
9427 fi
9428 fi
9429 fi
9430
9431
9432
9433 if test "x$SORT" = x; then
9434 as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9435 fi
9436
9437
9438
9439
9440
9441 # Publish this variable in the help.
9442
9443
9444 if test "x$TAIL" = x; then
9445 # The variable is not set by user, try to locate tool using the code snippet
9446 for ac_prog in tail
9447 do
9448 # Extract the first word of "$ac_prog", so it can be a program name with args.
9449 set dummy $ac_prog; ac_word=$2
9450 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9451 $as_echo_n "checking for $ac_word... " >&6; }
9452 if ${ac_cv_path_TAIL+:} false; then :
9453 $as_echo_n "(cached) " >&6
9454 else
9455 case $TAIL in
9456 [\\/]* | ?:[\\/]*)
9457 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9458 ;;
9459 *)
9460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9461 for as_dir in $PATH
9462 do
9463 IFS=$as_save_IFS
9464 test -z "$as_dir" && as_dir=.
9465 for ac_exec_ext in '' $ac_executable_extensions; do
9466 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9467 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9468 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9469 break 2
9470 fi
9471 done
9472 done
9473 IFS=$as_save_IFS
9474
9475 ;;
9476 esac
9477 fi
9478 TAIL=$ac_cv_path_TAIL
9479 if test -n "$TAIL"; then
9480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9481 $as_echo "$TAIL" >&6; }
9482 else
9483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9484 $as_echo "no" >&6; }
9485 fi
9486
9487
9488 test -n "$TAIL" && break
9489 done
9490
9491 else
9492 # The variable is set, but is it from the command line or the environment?
9493
9494 # Try to remove the string !TAIL! from our list.
9495 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9496 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9497 # If it failed, the variable was not from the command line. Ignore it,
9498 # but warn the user (except for BASH, which is always set by the calling BASH).
9499 if test "xTAIL" != xBASH; then
9500 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9501 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9502 fi
9503 # Try to locate tool using the code snippet
9504 for ac_prog in tail
9505 do
9506 # Extract the first word of "$ac_prog", so it can be a program name with args.
9507 set dummy $ac_prog; ac_word=$2
9508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9509 $as_echo_n "checking for $ac_word... " >&6; }
9510 if ${ac_cv_path_TAIL+:} false; then :
9511 $as_echo_n "(cached) " >&6
9512 else
9513 case $TAIL in
9514 [\\/]* | ?:[\\/]*)
9515 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9516 ;;
9517 *)
9518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9519 for as_dir in $PATH
9520 do
9521 IFS=$as_save_IFS
9522 test -z "$as_dir" && as_dir=.
9523 for ac_exec_ext in '' $ac_executable_extensions; do
9524 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9525 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9526 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9527 break 2
9528 fi
9529 done
9530 done
9531 IFS=$as_save_IFS
9532
9533 ;;
9534 esac
9535 fi
9536 TAIL=$ac_cv_path_TAIL
9537 if test -n "$TAIL"; then
9538 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9539 $as_echo "$TAIL" >&6; }
9540 else
9541 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9542 $as_echo "no" >&6; }
9543 fi
9544
9545
9546 test -n "$TAIL" && break
9547 done
9548
9549 else
9550 # If it succeeded, then it was overridden by the user. We will use it
9551 # for the tool.
9552
9553 # First remove it from the list of overridden variables, so we can test
9554 # for unknown variables in the end.
9555 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9556
9557 # Check if the provided tool contains a complete path.
9558 tool_specified="$TAIL"
9559 tool_basename="${tool_specified##*/}"
9560 if test "x$tool_basename" = "x$tool_specified"; then
9561 # A command without a complete path is provided, search $PATH.
9562 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9563 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9564 # Extract the first word of "$tool_basename", so it can be a program name with args.
9565 set dummy $tool_basename; ac_word=$2
9566 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9567 $as_echo_n "checking for $ac_word... " >&6; }
9568 if ${ac_cv_path_TAIL+:} false; then :
9569 $as_echo_n "(cached) " >&6
9570 else
9571 case $TAIL in
9572 [\\/]* | ?:[\\/]*)
9573 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9574 ;;
9575 *)
9576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9577 for as_dir in $PATH
9578 do
9579 IFS=$as_save_IFS
9580 test -z "$as_dir" && as_dir=.
9581 for ac_exec_ext in '' $ac_executable_extensions; do
9582 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9583 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9584 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9585 break 2
9586 fi
9587 done
9588 done
9589 IFS=$as_save_IFS
9590
9591 ;;
9592 esac
9593 fi
9594 TAIL=$ac_cv_path_TAIL
9595 if test -n "$TAIL"; then
9596 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9597 $as_echo "$TAIL" >&6; }
9598 else
9599 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9600 $as_echo "no" >&6; }
9601 fi
9602
9603
9604 if test "x$TAIL" = x; then
9605 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9606 fi
9607 else
9608 # Otherwise we believe it is a complete path. Use it as it is.
9609 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9610 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9612 $as_echo_n "checking for TAIL... " >&6; }
9613 if test ! -x "$tool_specified"; then
9614 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9615 $as_echo "not found" >&6; }
9616 as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9617 fi
9618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9619 $as_echo "$tool_specified" >&6; }
9620 fi
9621 fi
9622 fi
9623
9624
9625
9626 if test "x$TAIL" = x; then
9627 as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9628 fi
9629
9630
9631
9632
9633
9634 # Publish this variable in the help.
9635
9636
9637 if test "x$TAR" = x; then
9638 # The variable is not set by user, try to locate tool using the code snippet
9639 for ac_prog in tar
9640 do
9641 # Extract the first word of "$ac_prog", so it can be a program name with args.
9642 set dummy $ac_prog; ac_word=$2
9643 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9644 $as_echo_n "checking for $ac_word... " >&6; }
9645 if ${ac_cv_path_TAR+:} false; then :
9646 $as_echo_n "(cached) " >&6
9647 else
9648 case $TAR in
9649 [\\/]* | ?:[\\/]*)
9650 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9651 ;;
9652 *)
9653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9654 for as_dir in $PATH
9655 do
9656 IFS=$as_save_IFS
9657 test -z "$as_dir" && as_dir=.
9658 for ac_exec_ext in '' $ac_executable_extensions; do
9659 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9660 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9661 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9662 break 2
9663 fi
9664 done
9665 done
9666 IFS=$as_save_IFS
9667
9668 ;;
9669 esac
9670 fi
9671 TAR=$ac_cv_path_TAR
9672 if test -n "$TAR"; then
9673 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9674 $as_echo "$TAR" >&6; }
9675 else
9676 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9677 $as_echo "no" >&6; }
9678 fi
9679
9680
9681 test -n "$TAR" && break
9682 done
9683
9684 else
9685 # The variable is set, but is it from the command line or the environment?
9686
9687 # Try to remove the string !TAR! from our list.
9688 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9689 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9690 # If it failed, the variable was not from the command line. Ignore it,
9691 # but warn the user (except for BASH, which is always set by the calling BASH).
9692 if test "xTAR" != xBASH; then
9693 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9694 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9695 fi
9696 # Try to locate tool using the code snippet
9697 for ac_prog in tar
9698 do
9699 # Extract the first word of "$ac_prog", so it can be a program name with args.
9700 set dummy $ac_prog; ac_word=$2
9701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9702 $as_echo_n "checking for $ac_word... " >&6; }
9703 if ${ac_cv_path_TAR+:} false; then :
9704 $as_echo_n "(cached) " >&6
9705 else
9706 case $TAR in
9707 [\\/]* | ?:[\\/]*)
9708 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9709 ;;
9710 *)
9711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9712 for as_dir in $PATH
9713 do
9714 IFS=$as_save_IFS
9715 test -z "$as_dir" && as_dir=.
9716 for ac_exec_ext in '' $ac_executable_extensions; do
9717 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9718 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9719 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9720 break 2
9721 fi
9722 done
9723 done
9724 IFS=$as_save_IFS
9725
9726 ;;
9727 esac
9728 fi
9729 TAR=$ac_cv_path_TAR
9730 if test -n "$TAR"; then
9731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9732 $as_echo "$TAR" >&6; }
9733 else
9734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9735 $as_echo "no" >&6; }
9736 fi
9737
9738
9739 test -n "$TAR" && break
9740 done
9741
9742 else
9743 # If it succeeded, then it was overridden by the user. We will use it
9744 # for the tool.
9745
9746 # First remove it from the list of overridden variables, so we can test
9747 # for unknown variables in the end.
9748 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9749
9750 # Check if the provided tool contains a complete path.
9751 tool_specified="$TAR"
9752 tool_basename="${tool_specified##*/}"
9753 if test "x$tool_basename" = "x$tool_specified"; then
9754 # A command without a complete path is provided, search $PATH.
9755 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9756 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9757 # Extract the first word of "$tool_basename", so it can be a program name with args.
9758 set dummy $tool_basename; ac_word=$2
9759 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9760 $as_echo_n "checking for $ac_word... " >&6; }
9761 if ${ac_cv_path_TAR+:} false; then :
9762 $as_echo_n "(cached) " >&6
9763 else
9764 case $TAR in
9765 [\\/]* | ?:[\\/]*)
9766 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9767 ;;
9768 *)
9769 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9770 for as_dir in $PATH
9771 do
9772 IFS=$as_save_IFS
9773 test -z "$as_dir" && as_dir=.
9774 for ac_exec_ext in '' $ac_executable_extensions; do
9775 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9776 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9777 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9778 break 2
9779 fi
9780 done
9781 done
9782 IFS=$as_save_IFS
9783
9784 ;;
9785 esac
9786 fi
9787 TAR=$ac_cv_path_TAR
9788 if test -n "$TAR"; then
9789 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9790 $as_echo "$TAR" >&6; }
9791 else
9792 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9793 $as_echo "no" >&6; }
9794 fi
9795
9796
9797 if test "x$TAR" = x; then
9798 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9799 fi
9800 else
9801 # Otherwise we believe it is a complete path. Use it as it is.
9802 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9803 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9804 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9805 $as_echo_n "checking for TAR... " >&6; }
9806 if test ! -x "$tool_specified"; then
9807 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9808 $as_echo "not found" >&6; }
9809 as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9810 fi
9811 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9812 $as_echo "$tool_specified" >&6; }
9813 fi
9814 fi
9815 fi
9816
9817
9818
9819 if test "x$TAR" = x; then
9820 as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9821 fi
9822
9823
9824
9825
9826
9827 # Publish this variable in the help.
9828
9829
9830 if test "x$TEE" = x; then
9831 # The variable is not set by user, try to locate tool using the code snippet
9832 for ac_prog in tee
9833 do
9834 # Extract the first word of "$ac_prog", so it can be a program name with args.
9835 set dummy $ac_prog; ac_word=$2
9836 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9837 $as_echo_n "checking for $ac_word... " >&6; }
9838 if ${ac_cv_path_TEE+:} false; then :
9839 $as_echo_n "(cached) " >&6
9840 else
9841 case $TEE in
9842 [\\/]* | ?:[\\/]*)
9843 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9844 ;;
9845 *)
9846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9847 for as_dir in $PATH
9848 do
9849 IFS=$as_save_IFS
9850 test -z "$as_dir" && as_dir=.
9851 for ac_exec_ext in '' $ac_executable_extensions; do
9852 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9853 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9854 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9855 break 2
9856 fi
9857 done
9858 done
9859 IFS=$as_save_IFS
9860
9861 ;;
9862 esac
9863 fi
9864 TEE=$ac_cv_path_TEE
9865 if test -n "$TEE"; then
9866 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9867 $as_echo "$TEE" >&6; }
9868 else
9869 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9870 $as_echo "no" >&6; }
9871 fi
9872
9873
9874 test -n "$TEE" && break
9875 done
9876
9877 else
9878 # The variable is set, but is it from the command line or the environment?
9879
9880 # Try to remove the string !TEE! from our list.
9881 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9882 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9883 # If it failed, the variable was not from the command line. Ignore it,
9884 # but warn the user (except for BASH, which is always set by the calling BASH).
9885 if test "xTEE" != xBASH; then
9886 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9887 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9888 fi
9889 # Try to locate tool using the code snippet
9890 for ac_prog in tee
9891 do
9892 # Extract the first word of "$ac_prog", so it can be a program name with args.
9893 set dummy $ac_prog; ac_word=$2
9894 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9895 $as_echo_n "checking for $ac_word... " >&6; }
9896 if ${ac_cv_path_TEE+:} false; then :
9897 $as_echo_n "(cached) " >&6
9898 else
9899 case $TEE in
9900 [\\/]* | ?:[\\/]*)
9901 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9902 ;;
9903 *)
9904 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9905 for as_dir in $PATH
9906 do
9907 IFS=$as_save_IFS
9908 test -z "$as_dir" && as_dir=.
9909 for ac_exec_ext in '' $ac_executable_extensions; do
9910 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9911 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9912 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9913 break 2
9914 fi
9915 done
9916 done
9917 IFS=$as_save_IFS
9918
9919 ;;
9920 esac
9921 fi
9922 TEE=$ac_cv_path_TEE
9923 if test -n "$TEE"; then
9924 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9925 $as_echo "$TEE" >&6; }
9926 else
9927 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9928 $as_echo "no" >&6; }
9929 fi
9930
9931
9932 test -n "$TEE" && break
9933 done
9934
9935 else
9936 # If it succeeded, then it was overridden by the user. We will use it
9937 # for the tool.
9938
9939 # First remove it from the list of overridden variables, so we can test
9940 # for unknown variables in the end.
9941 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9942
9943 # Check if the provided tool contains a complete path.
9944 tool_specified="$TEE"
9945 tool_basename="${tool_specified##*/}"
9946 if test "x$tool_basename" = "x$tool_specified"; then
9947 # A command without a complete path is provided, search $PATH.
9948 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9949 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9950 # Extract the first word of "$tool_basename", so it can be a program name with args.
9951 set dummy $tool_basename; ac_word=$2
9952 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9953 $as_echo_n "checking for $ac_word... " >&6; }
9954 if ${ac_cv_path_TEE+:} false; then :
9955 $as_echo_n "(cached) " >&6
9956 else
9957 case $TEE in
9958 [\\/]* | ?:[\\/]*)
9959 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9960 ;;
9961 *)
9962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9963 for as_dir in $PATH
9964 do
9965 IFS=$as_save_IFS
9966 test -z "$as_dir" && as_dir=.
9967 for ac_exec_ext in '' $ac_executable_extensions; do
9968 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9969 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9970 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9971 break 2
9972 fi
9973 done
9974 done
9975 IFS=$as_save_IFS
9976
9977 ;;
9978 esac
9979 fi
9980 TEE=$ac_cv_path_TEE
9981 if test -n "$TEE"; then
9982 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9983 $as_echo "$TEE" >&6; }
9984 else
9985 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9986 $as_echo "no" >&6; }
9987 fi
9988
9989
9990 if test "x$TEE" = x; then
9991 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9992 fi
9993 else
9994 # Otherwise we believe it is a complete path. Use it as it is.
9995 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9996 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9997 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9998 $as_echo_n "checking for TEE... " >&6; }
9999 if test ! -x "$tool_specified"; then
10000 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10001 $as_echo "not found" >&6; }
10002 as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10003 fi
10004 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10005 $as_echo "$tool_specified" >&6; }
10006 fi
10007 fi
10008 fi
10009
10010
10011
10012 if test "x$TEE" = x; then
10013 as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10014 fi
10015
10016
10017
10018
10019
10020 # Publish this variable in the help.
10021
10022
10023 if test "x$TOUCH" = x; then
10024 # The variable is not set by user, try to locate tool using the code snippet
10025 for ac_prog in touch
10026 do
10027 # Extract the first word of "$ac_prog", so it can be a program name with args.
10028 set dummy $ac_prog; ac_word=$2
10029 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10030 $as_echo_n "checking for $ac_word... " >&6; }
10031 if ${ac_cv_path_TOUCH+:} false; then :
10032 $as_echo_n "(cached) " >&6
10033 else
10034 case $TOUCH in
10035 [\\/]* | ?:[\\/]*)
10036 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10037 ;;
10038 *)
10039 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10040 for as_dir in $PATH
10041 do
10042 IFS=$as_save_IFS
10043 test -z "$as_dir" && as_dir=.
10044 for ac_exec_ext in '' $ac_executable_extensions; do
10045 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10046 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10047 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10048 break 2
10049 fi
10050 done
10051 done
10052 IFS=$as_save_IFS
10053
10054 ;;
10055 esac
10056 fi
10057 TOUCH=$ac_cv_path_TOUCH
10058 if test -n "$TOUCH"; then
10059 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10060 $as_echo "$TOUCH" >&6; }
10061 else
10062 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10063 $as_echo "no" >&6; }
10064 fi
10065
10066
10067 test -n "$TOUCH" && break
10068 done
10069
10070 else
10071 # The variable is set, but is it from the command line or the environment?
10072
10073 # Try to remove the string !TOUCH! from our list.
10074 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10075 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10076 # If it failed, the variable was not from the command line. Ignore it,
10077 # but warn the user (except for BASH, which is always set by the calling BASH).
10078 if test "xTOUCH" != xBASH; then
10079 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10080 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10081 fi
10082 # Try to locate tool using the code snippet
10083 for ac_prog in touch
10084 do
10085 # Extract the first word of "$ac_prog", so it can be a program name with args.
10086 set dummy $ac_prog; ac_word=$2
10087 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10088 $as_echo_n "checking for $ac_word... " >&6; }
10089 if ${ac_cv_path_TOUCH+:} false; then :
10090 $as_echo_n "(cached) " >&6
10091 else
10092 case $TOUCH in
10093 [\\/]* | ?:[\\/]*)
10094 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10095 ;;
10096 *)
10097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10098 for as_dir in $PATH
10099 do
10100 IFS=$as_save_IFS
10101 test -z "$as_dir" && as_dir=.
10102 for ac_exec_ext in '' $ac_executable_extensions; do
10103 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10104 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10105 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10106 break 2
10107 fi
10108 done
10109 done
10110 IFS=$as_save_IFS
10111
10112 ;;
10113 esac
10114 fi
10115 TOUCH=$ac_cv_path_TOUCH
10116 if test -n "$TOUCH"; then
10117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10118 $as_echo "$TOUCH" >&6; }
10119 else
10120 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10121 $as_echo "no" >&6; }
10122 fi
10123
10124
10125 test -n "$TOUCH" && break
10126 done
10127
10128 else
10129 # If it succeeded, then it was overridden by the user. We will use it
10130 # for the tool.
10131
10132 # First remove it from the list of overridden variables, so we can test
10133 # for unknown variables in the end.
10134 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10135
10136 # Check if the provided tool contains a complete path.
10137 tool_specified="$TOUCH"
10138 tool_basename="${tool_specified##*/}"
10139 if test "x$tool_basename" = "x$tool_specified"; then
10140 # A command without a complete path is provided, search $PATH.
10141 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10142 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10143 # Extract the first word of "$tool_basename", so it can be a program name with args.
10144 set dummy $tool_basename; ac_word=$2
10145 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10146 $as_echo_n "checking for $ac_word... " >&6; }
10147 if ${ac_cv_path_TOUCH+:} false; then :
10148 $as_echo_n "(cached) " >&6
10149 else
10150 case $TOUCH in
10151 [\\/]* | ?:[\\/]*)
10152 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10153 ;;
10154 *)
10155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10156 for as_dir in $PATH
10157 do
10158 IFS=$as_save_IFS
10159 test -z "$as_dir" && as_dir=.
10160 for ac_exec_ext in '' $ac_executable_extensions; do
10161 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10162 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10163 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10164 break 2
10165 fi
10166 done
10167 done
10168 IFS=$as_save_IFS
10169
10170 ;;
10171 esac
10172 fi
10173 TOUCH=$ac_cv_path_TOUCH
10174 if test -n "$TOUCH"; then
10175 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10176 $as_echo "$TOUCH" >&6; }
10177 else
10178 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10179 $as_echo "no" >&6; }
10180 fi
10181
10182
10183 if test "x$TOUCH" = x; then
10184 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10185 fi
10186 else
10187 # Otherwise we believe it is a complete path. Use it as it is.
10188 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10189 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10190 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10191 $as_echo_n "checking for TOUCH... " >&6; }
10192 if test ! -x "$tool_specified"; then
10193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10194 $as_echo "not found" >&6; }
10195 as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10196 fi
10197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10198 $as_echo "$tool_specified" >&6; }
10199 fi
10200 fi
10201 fi
10202
10203
10204
10205 if test "x$TOUCH" = x; then
10206 as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10207 fi
10208
10209
10210
10211
10212
10213 # Publish this variable in the help.
10214
10215
10216 if test "x$TR" = x; then
10217 # The variable is not set by user, try to locate tool using the code snippet
10218 for ac_prog in tr
10219 do
10220 # Extract the first word of "$ac_prog", so it can be a program name with args.
10221 set dummy $ac_prog; ac_word=$2
10222 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10223 $as_echo_n "checking for $ac_word... " >&6; }
10224 if ${ac_cv_path_TR+:} false; then :
10225 $as_echo_n "(cached) " >&6
10226 else
10227 case $TR in
10228 [\\/]* | ?:[\\/]*)
10229 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10230 ;;
10231 *)
10232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10233 for as_dir in $PATH
10234 do
10235 IFS=$as_save_IFS
10236 test -z "$as_dir" && as_dir=.
10237 for ac_exec_ext in '' $ac_executable_extensions; do
10238 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10239 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10240 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10241 break 2
10242 fi
10243 done
10244 done
10245 IFS=$as_save_IFS
10246
10247 ;;
10248 esac
10249 fi
10250 TR=$ac_cv_path_TR
10251 if test -n "$TR"; then
10252 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10253 $as_echo "$TR" >&6; }
10254 else
10255 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10256 $as_echo "no" >&6; }
10257 fi
10258
10259
10260 test -n "$TR" && break
10261 done
10262
10263 else
10264 # The variable is set, but is it from the command line or the environment?
10265
10266 # Try to remove the string !TR! from our list.
10267 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10268 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10269 # If it failed, the variable was not from the command line. Ignore it,
10270 # but warn the user (except for BASH, which is always set by the calling BASH).
10271 if test "xTR" != xBASH; then
10272 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10273 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10274 fi
10275 # Try to locate tool using the code snippet
10276 for ac_prog in tr
10277 do
10278 # Extract the first word of "$ac_prog", so it can be a program name with args.
10279 set dummy $ac_prog; ac_word=$2
10280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10281 $as_echo_n "checking for $ac_word... " >&6; }
10282 if ${ac_cv_path_TR+:} false; then :
10283 $as_echo_n "(cached) " >&6
10284 else
10285 case $TR in
10286 [\\/]* | ?:[\\/]*)
10287 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10288 ;;
10289 *)
10290 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10291 for as_dir in $PATH
10292 do
10293 IFS=$as_save_IFS
10294 test -z "$as_dir" && as_dir=.
10295 for ac_exec_ext in '' $ac_executable_extensions; do
10296 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10297 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10298 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10299 break 2
10300 fi
10301 done
10302 done
10303 IFS=$as_save_IFS
10304
10305 ;;
10306 esac
10307 fi
10308 TR=$ac_cv_path_TR
10309 if test -n "$TR"; then
10310 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10311 $as_echo "$TR" >&6; }
10312 else
10313 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10314 $as_echo "no" >&6; }
10315 fi
10316
10317
10318 test -n "$TR" && break
10319 done
10320
10321 else
10322 # If it succeeded, then it was overridden by the user. We will use it
10323 # for the tool.
10324
10325 # First remove it from the list of overridden variables, so we can test
10326 # for unknown variables in the end.
10327 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10328
10329 # Check if the provided tool contains a complete path.
10330 tool_specified="$TR"
10331 tool_basename="${tool_specified##*/}"
10332 if test "x$tool_basename" = "x$tool_specified"; then
10333 # A command without a complete path is provided, search $PATH.
10334 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10335 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10336 # Extract the first word of "$tool_basename", so it can be a program name with args.
10337 set dummy $tool_basename; ac_word=$2
10338 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10339 $as_echo_n "checking for $ac_word... " >&6; }
10340 if ${ac_cv_path_TR+:} false; then :
10341 $as_echo_n "(cached) " >&6
10342 else
10343 case $TR in
10344 [\\/]* | ?:[\\/]*)
10345 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10346 ;;
10347 *)
10348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10349 for as_dir in $PATH
10350 do
10351 IFS=$as_save_IFS
10352 test -z "$as_dir" && as_dir=.
10353 for ac_exec_ext in '' $ac_executable_extensions; do
10354 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10355 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10356 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10357 break 2
10358 fi
10359 done
10360 done
10361 IFS=$as_save_IFS
10362
10363 ;;
10364 esac
10365 fi
10366 TR=$ac_cv_path_TR
10367 if test -n "$TR"; then
10368 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10369 $as_echo "$TR" >&6; }
10370 else
10371 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10372 $as_echo "no" >&6; }
10373 fi
10374
10375
10376 if test "x$TR" = x; then
10377 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10378 fi
10379 else
10380 # Otherwise we believe it is a complete path. Use it as it is.
10381 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10382 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10383 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10384 $as_echo_n "checking for TR... " >&6; }
10385 if test ! -x "$tool_specified"; then
10386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10387 $as_echo "not found" >&6; }
10388 as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10389 fi
10390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10391 $as_echo "$tool_specified" >&6; }
10392 fi
10393 fi
10394 fi
10395
10396
10397
10398 if test "x$TR" = x; then
10399 as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10400 fi
10401
10402
10403
10404
10405
10406 # Publish this variable in the help.
10407
10408
10409 if test "x$UNAME" = x; then
10410 # The variable is not set by user, try to locate tool using the code snippet
10411 for ac_prog in uname
10412 do
10413 # Extract the first word of "$ac_prog", so it can be a program name with args.
10414 set dummy $ac_prog; ac_word=$2
10415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10416 $as_echo_n "checking for $ac_word... " >&6; }
10417 if ${ac_cv_path_UNAME+:} false; then :
10418 $as_echo_n "(cached) " >&6
10419 else
10420 case $UNAME in
10421 [\\/]* | ?:[\\/]*)
10422 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10423 ;;
10424 *)
10425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10426 for as_dir in $PATH
10427 do
10428 IFS=$as_save_IFS
10429 test -z "$as_dir" && as_dir=.
10430 for ac_exec_ext in '' $ac_executable_extensions; do
10431 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10432 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10433 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10434 break 2
10435 fi
10436 done
10437 done
10438 IFS=$as_save_IFS
10439
10440 ;;
10441 esac
10442 fi
10443 UNAME=$ac_cv_path_UNAME
10444 if test -n "$UNAME"; then
10445 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10446 $as_echo "$UNAME" >&6; }
10447 else
10448 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10449 $as_echo "no" >&6; }
10450 fi
10451
10452
10453 test -n "$UNAME" && break
10454 done
10455
10456 else
10457 # The variable is set, but is it from the command line or the environment?
10458
10459 # Try to remove the string !UNAME! from our list.
10460 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10461 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10462 # If it failed, the variable was not from the command line. Ignore it,
10463 # but warn the user (except for BASH, which is always set by the calling BASH).
10464 if test "xUNAME" != xBASH; then
10465 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10466 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10467 fi
10468 # Try to locate tool using the code snippet
10469 for ac_prog in uname
10470 do
10471 # Extract the first word of "$ac_prog", so it can be a program name with args.
10472 set dummy $ac_prog; ac_word=$2
10473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10474 $as_echo_n "checking for $ac_word... " >&6; }
10475 if ${ac_cv_path_UNAME+:} false; then :
10476 $as_echo_n "(cached) " >&6
10477 else
10478 case $UNAME in
10479 [\\/]* | ?:[\\/]*)
10480 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10481 ;;
10482 *)
10483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10484 for as_dir in $PATH
10485 do
10486 IFS=$as_save_IFS
10487 test -z "$as_dir" && as_dir=.
10488 for ac_exec_ext in '' $ac_executable_extensions; do
10489 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10490 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10491 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10492 break 2
10493 fi
10494 done
10495 done
10496 IFS=$as_save_IFS
10497
10498 ;;
10499 esac
10500 fi
10501 UNAME=$ac_cv_path_UNAME
10502 if test -n "$UNAME"; then
10503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10504 $as_echo "$UNAME" >&6; }
10505 else
10506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10507 $as_echo "no" >&6; }
10508 fi
10509
10510
10511 test -n "$UNAME" && break
10512 done
10513
10514 else
10515 # If it succeeded, then it was overridden by the user. We will use it
10516 # for the tool.
10517
10518 # First remove it from the list of overridden variables, so we can test
10519 # for unknown variables in the end.
10520 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10521
10522 # Check if the provided tool contains a complete path.
10523 tool_specified="$UNAME"
10524 tool_basename="${tool_specified##*/}"
10525 if test "x$tool_basename" = "x$tool_specified"; then
10526 # A command without a complete path is provided, search $PATH.
10527 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10528 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10529 # Extract the first word of "$tool_basename", so it can be a program name with args.
10530 set dummy $tool_basename; ac_word=$2
10531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10532 $as_echo_n "checking for $ac_word... " >&6; }
10533 if ${ac_cv_path_UNAME+:} false; then :
10534 $as_echo_n "(cached) " >&6
10535 else
10536 case $UNAME in
10537 [\\/]* | ?:[\\/]*)
10538 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10539 ;;
10540 *)
10541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10542 for as_dir in $PATH
10543 do
10544 IFS=$as_save_IFS
10545 test -z "$as_dir" && as_dir=.
10546 for ac_exec_ext in '' $ac_executable_extensions; do
10547 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10548 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10549 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10550 break 2
10551 fi
10552 done
10553 done
10554 IFS=$as_save_IFS
10555
10556 ;;
10557 esac
10558 fi
10559 UNAME=$ac_cv_path_UNAME
10560 if test -n "$UNAME"; then
10561 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10562 $as_echo "$UNAME" >&6; }
10563 else
10564 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10565 $as_echo "no" >&6; }
10566 fi
10567
10568
10569 if test "x$UNAME" = x; then
10570 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10571 fi
10572 else
10573 # Otherwise we believe it is a complete path. Use it as it is.
10574 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10575 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10577 $as_echo_n "checking for UNAME... " >&6; }
10578 if test ! -x "$tool_specified"; then
10579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10580 $as_echo "not found" >&6; }
10581 as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10582 fi
10583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10584 $as_echo "$tool_specified" >&6; }
10585 fi
10586 fi
10587 fi
10588
10589
10590
10591 if test "x$UNAME" = x; then
10592 as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10593 fi
10594
10595
10596
10597
10598
10599 # Publish this variable in the help.
10600
10601
10602 if test "x$UNIQ" = x; then
10603 # The variable is not set by user, try to locate tool using the code snippet
10604 for ac_prog in uniq
10605 do
10606 # Extract the first word of "$ac_prog", so it can be a program name with args.
10607 set dummy $ac_prog; ac_word=$2
10608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10609 $as_echo_n "checking for $ac_word... " >&6; }
10610 if ${ac_cv_path_UNIQ+:} false; then :
10611 $as_echo_n "(cached) " >&6
10612 else
10613 case $UNIQ in
10614 [\\/]* | ?:[\\/]*)
10615 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10616 ;;
10617 *)
10618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10619 for as_dir in $PATH
10620 do
10621 IFS=$as_save_IFS
10622 test -z "$as_dir" && as_dir=.
10623 for ac_exec_ext in '' $ac_executable_extensions; do
10624 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10625 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10626 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10627 break 2
10628 fi
10629 done
10630 done
10631 IFS=$as_save_IFS
10632
10633 ;;
10634 esac
10635 fi
10636 UNIQ=$ac_cv_path_UNIQ
10637 if test -n "$UNIQ"; then
10638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10639 $as_echo "$UNIQ" >&6; }
10640 else
10641 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10642 $as_echo "no" >&6; }
10643 fi
10644
10645
10646 test -n "$UNIQ" && break
10647 done
10648
10649 else
10650 # The variable is set, but is it from the command line or the environment?
10651
10652 # Try to remove the string !UNIQ! from our list.
10653 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10654 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10655 # If it failed, the variable was not from the command line. Ignore it,
10656 # but warn the user (except for BASH, which is always set by the calling BASH).
10657 if test "xUNIQ" != xBASH; then
10658 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10659 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10660 fi
10661 # Try to locate tool using the code snippet
10662 for ac_prog in uniq
10663 do
10664 # Extract the first word of "$ac_prog", so it can be a program name with args.
10665 set dummy $ac_prog; ac_word=$2
10666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10667 $as_echo_n "checking for $ac_word... " >&6; }
10668 if ${ac_cv_path_UNIQ+:} false; then :
10669 $as_echo_n "(cached) " >&6
10670 else
10671 case $UNIQ in
10672 [\\/]* | ?:[\\/]*)
10673 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10674 ;;
10675 *)
10676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10677 for as_dir in $PATH
10678 do
10679 IFS=$as_save_IFS
10680 test -z "$as_dir" && as_dir=.
10681 for ac_exec_ext in '' $ac_executable_extensions; do
10682 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10683 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10684 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10685 break 2
10686 fi
10687 done
10688 done
10689 IFS=$as_save_IFS
10690
10691 ;;
10692 esac
10693 fi
10694 UNIQ=$ac_cv_path_UNIQ
10695 if test -n "$UNIQ"; then
10696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10697 $as_echo "$UNIQ" >&6; }
10698 else
10699 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10700 $as_echo "no" >&6; }
10701 fi
10702
10703
10704 test -n "$UNIQ" && break
10705 done
10706
10707 else
10708 # If it succeeded, then it was overridden by the user. We will use it
10709 # for the tool.
10710
10711 # First remove it from the list of overridden variables, so we can test
10712 # for unknown variables in the end.
10713 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10714
10715 # Check if the provided tool contains a complete path.
10716 tool_specified="$UNIQ"
10717 tool_basename="${tool_specified##*/}"
10718 if test "x$tool_basename" = "x$tool_specified"; then
10719 # A command without a complete path is provided, search $PATH.
10720 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10721 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10722 # Extract the first word of "$tool_basename", so it can be a program name with args.
10723 set dummy $tool_basename; ac_word=$2
10724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10725 $as_echo_n "checking for $ac_word... " >&6; }
10726 if ${ac_cv_path_UNIQ+:} false; then :
10727 $as_echo_n "(cached) " >&6
10728 else
10729 case $UNIQ in
10730 [\\/]* | ?:[\\/]*)
10731 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10732 ;;
10733 *)
10734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10735 for as_dir in $PATH
10736 do
10737 IFS=$as_save_IFS
10738 test -z "$as_dir" && as_dir=.
10739 for ac_exec_ext in '' $ac_executable_extensions; do
10740 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10741 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10742 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10743 break 2
10744 fi
10745 done
10746 done
10747 IFS=$as_save_IFS
10748
10749 ;;
10750 esac
10751 fi
10752 UNIQ=$ac_cv_path_UNIQ
10753 if test -n "$UNIQ"; then
10754 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10755 $as_echo "$UNIQ" >&6; }
10756 else
10757 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10758 $as_echo "no" >&6; }
10759 fi
10760
10761
10762 if test "x$UNIQ" = x; then
10763 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10764 fi
10765 else
10766 # Otherwise we believe it is a complete path. Use it as it is.
10767 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10768 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10769 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10770 $as_echo_n "checking for UNIQ... " >&6; }
10771 if test ! -x "$tool_specified"; then
10772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10773 $as_echo "not found" >&6; }
10774 as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10775 fi
10776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10777 $as_echo "$tool_specified" >&6; }
10778 fi
10779 fi
10780 fi
10781
10782
10783
10784 if test "x$UNIQ" = x; then
10785 as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10786 fi
10787
10788
10789
10790
10791
10792 # Publish this variable in the help.
10793
10794
10795 if test "x$WC" = x; then
10796 # The variable is not set by user, try to locate tool using the code snippet
10797 for ac_prog in wc
10798 do
10799 # Extract the first word of "$ac_prog", so it can be a program name with args.
10800 set dummy $ac_prog; ac_word=$2
10801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10802 $as_echo_n "checking for $ac_word... " >&6; }
10803 if ${ac_cv_path_WC+:} false; then :
10804 $as_echo_n "(cached) " >&6
10805 else
10806 case $WC in
10807 [\\/]* | ?:[\\/]*)
10808 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10809 ;;
10810 *)
10811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10812 for as_dir in $PATH
10813 do
10814 IFS=$as_save_IFS
10815 test -z "$as_dir" && as_dir=.
10816 for ac_exec_ext in '' $ac_executable_extensions; do
10817 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10818 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10819 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10820 break 2
10821 fi
10822 done
10823 done
10824 IFS=$as_save_IFS
10825
10826 ;;
10827 esac
10828 fi
10829 WC=$ac_cv_path_WC
10830 if test -n "$WC"; then
10831 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10832 $as_echo "$WC" >&6; }
10833 else
10834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10835 $as_echo "no" >&6; }
10836 fi
10837
10838
10839 test -n "$WC" && break
10840 done
10841
10842 else
10843 # The variable is set, but is it from the command line or the environment?
10844
10845 # Try to remove the string !WC! from our list.
10846 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10847 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10848 # If it failed, the variable was not from the command line. Ignore it,
10849 # but warn the user (except for BASH, which is always set by the calling BASH).
10850 if test "xWC" != xBASH; then
10851 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10852 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10853 fi
10854 # Try to locate tool using the code snippet
10855 for ac_prog in wc
10856 do
10857 # Extract the first word of "$ac_prog", so it can be a program name with args.
10858 set dummy $ac_prog; ac_word=$2
10859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10860 $as_echo_n "checking for $ac_word... " >&6; }
10861 if ${ac_cv_path_WC+:} false; then :
10862 $as_echo_n "(cached) " >&6
10863 else
10864 case $WC in
10865 [\\/]* | ?:[\\/]*)
10866 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10867 ;;
10868 *)
10869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10870 for as_dir in $PATH
10871 do
10872 IFS=$as_save_IFS
10873 test -z "$as_dir" && as_dir=.
10874 for ac_exec_ext in '' $ac_executable_extensions; do
10875 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10876 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10877 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10878 break 2
10879 fi
10880 done
10881 done
10882 IFS=$as_save_IFS
10883
10884 ;;
10885 esac
10886 fi
10887 WC=$ac_cv_path_WC
10888 if test -n "$WC"; then
10889 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10890 $as_echo "$WC" >&6; }
10891 else
10892 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10893 $as_echo "no" >&6; }
10894 fi
10895
10896
10897 test -n "$WC" && break
10898 done
10899
10900 else
10901 # If it succeeded, then it was overridden by the user. We will use it
10902 # for the tool.
10903
10904 # First remove it from the list of overridden variables, so we can test
10905 # for unknown variables in the end.
10906 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10907
10908 # Check if the provided tool contains a complete path.
10909 tool_specified="$WC"
10910 tool_basename="${tool_specified##*/}"
10911 if test "x$tool_basename" = "x$tool_specified"; then
10912 # A command without a complete path is provided, search $PATH.
10913 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10914 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10915 # Extract the first word of "$tool_basename", so it can be a program name with args.
10916 set dummy $tool_basename; ac_word=$2
10917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10918 $as_echo_n "checking for $ac_word... " >&6; }
10919 if ${ac_cv_path_WC+:} false; then :
10920 $as_echo_n "(cached) " >&6
10921 else
10922 case $WC in
10923 [\\/]* | ?:[\\/]*)
10924 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10925 ;;
10926 *)
10927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10928 for as_dir in $PATH
10929 do
10930 IFS=$as_save_IFS
10931 test -z "$as_dir" && as_dir=.
10932 for ac_exec_ext in '' $ac_executable_extensions; do
10933 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10934 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10935 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10936 break 2
10937 fi
10938 done
10939 done
10940 IFS=$as_save_IFS
10941
10942 ;;
10943 esac
10944 fi
10945 WC=$ac_cv_path_WC
10946 if test -n "$WC"; then
10947 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10948 $as_echo "$WC" >&6; }
10949 else
10950 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10951 $as_echo "no" >&6; }
10952 fi
10953
10954
10955 if test "x$WC" = x; then
10956 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10957 fi
10958 else
10959 # Otherwise we believe it is a complete path. Use it as it is.
10960 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10961 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10963 $as_echo_n "checking for WC... " >&6; }
10964 if test ! -x "$tool_specified"; then
10965 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10966 $as_echo "not found" >&6; }
10967 as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10968 fi
10969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10970 $as_echo "$tool_specified" >&6; }
10971 fi
10972 fi
10973 fi
10974
10975
10976
10977 if test "x$WC" = x; then
10978 as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10979 fi
10980
10981
10982
10983
10984
10985 # Publish this variable in the help.
10986
10987
10988 if test "x$WHICH" = x; then
10989 # The variable is not set by user, try to locate tool using the code snippet
10990 for ac_prog in which
10991 do
10992 # Extract the first word of "$ac_prog", so it can be a program name with args.
10993 set dummy $ac_prog; ac_word=$2
10994 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10995 $as_echo_n "checking for $ac_word... " >&6; }
10996 if ${ac_cv_path_WHICH+:} false; then :
10997 $as_echo_n "(cached) " >&6
10998 else
10999 case $WHICH in
11000 [\\/]* | ?:[\\/]*)
11001 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11002 ;;
11003 *)
11004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11005 for as_dir in $PATH
11006 do
11007 IFS=$as_save_IFS
11008 test -z "$as_dir" && as_dir=.
11009 for ac_exec_ext in '' $ac_executable_extensions; do
11010 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11011 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11012 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11013 break 2
11014 fi
11015 done
11016 done
11017 IFS=$as_save_IFS
11018
11019 ;;
11020 esac
11021 fi
11022 WHICH=$ac_cv_path_WHICH
11023 if test -n "$WHICH"; then
11024 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11025 $as_echo "$WHICH" >&6; }
11026 else
11027 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11028 $as_echo "no" >&6; }
11029 fi
11030
11031
11032 test -n "$WHICH" && break
11033 done
11034
11035 else
11036 # The variable is set, but is it from the command line or the environment?
11037
11038 # Try to remove the string !WHICH! from our list.
11039 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11040 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11041 # If it failed, the variable was not from the command line. Ignore it,
11042 # but warn the user (except for BASH, which is always set by the calling BASH).
11043 if test "xWHICH" != xBASH; then
11044 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11045 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11046 fi
11047 # Try to locate tool using the code snippet
11048 for ac_prog in which
11049 do
11050 # Extract the first word of "$ac_prog", so it can be a program name with args.
11051 set dummy $ac_prog; ac_word=$2
11052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11053 $as_echo_n "checking for $ac_word... " >&6; }
11054 if ${ac_cv_path_WHICH+:} false; then :
11055 $as_echo_n "(cached) " >&6
11056 else
11057 case $WHICH in
11058 [\\/]* | ?:[\\/]*)
11059 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11060 ;;
11061 *)
11062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11063 for as_dir in $PATH
11064 do
11065 IFS=$as_save_IFS
11066 test -z "$as_dir" && as_dir=.
11067 for ac_exec_ext in '' $ac_executable_extensions; do
11068 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11069 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11070 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11071 break 2
11072 fi
11073 done
11074 done
11075 IFS=$as_save_IFS
11076
11077 ;;
11078 esac
11079 fi
11080 WHICH=$ac_cv_path_WHICH
11081 if test -n "$WHICH"; then
11082 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11083 $as_echo "$WHICH" >&6; }
11084 else
11085 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11086 $as_echo "no" >&6; }
11087 fi
11088
11089
11090 test -n "$WHICH" && break
11091 done
11092
11093 else
11094 # If it succeeded, then it was overridden by the user. We will use it
11095 # for the tool.
11096
11097 # First remove it from the list of overridden variables, so we can test
11098 # for unknown variables in the end.
11099 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11100
11101 # Check if the provided tool contains a complete path.
11102 tool_specified="$WHICH"
11103 tool_basename="${tool_specified##*/}"
11104 if test "x$tool_basename" = "x$tool_specified"; then
11105 # A command without a complete path is provided, search $PATH.
11106 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11107 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11108 # Extract the first word of "$tool_basename", so it can be a program name with args.
11109 set dummy $tool_basename; ac_word=$2
11110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11111 $as_echo_n "checking for $ac_word... " >&6; }
11112 if ${ac_cv_path_WHICH+:} false; then :
11113 $as_echo_n "(cached) " >&6
11114 else
11115 case $WHICH in
11116 [\\/]* | ?:[\\/]*)
11117 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11118 ;;
11119 *)
11120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11121 for as_dir in $PATH
11122 do
11123 IFS=$as_save_IFS
11124 test -z "$as_dir" && as_dir=.
11125 for ac_exec_ext in '' $ac_executable_extensions; do
11126 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11127 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11128 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11129 break 2
11130 fi
11131 done
11132 done
11133 IFS=$as_save_IFS
11134
11135 ;;
11136 esac
11137 fi
11138 WHICH=$ac_cv_path_WHICH
11139 if test -n "$WHICH"; then
11140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11141 $as_echo "$WHICH" >&6; }
11142 else
11143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11144 $as_echo "no" >&6; }
11145 fi
11146
11147
11148 if test "x$WHICH" = x; then
11149 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11150 fi
11151 else
11152 # Otherwise we believe it is a complete path. Use it as it is.
11153 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11154 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11156 $as_echo_n "checking for WHICH... " >&6; }
11157 if test ! -x "$tool_specified"; then
11158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11159 $as_echo "not found" >&6; }
11160 as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11161 fi
11162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11163 $as_echo "$tool_specified" >&6; }
11164 fi
11165 fi
11166 fi
11167
11168
11169
11170 if test "x$WHICH" = x; then
11171 as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11172 fi
11173
11174
11175
11176
11177
11178 # Publish this variable in the help.
11179
11180
11181 if test "x$XARGS" = x; then
11182 # The variable is not set by user, try to locate tool using the code snippet
11183 for ac_prog in xargs
11184 do
11185 # Extract the first word of "$ac_prog", so it can be a program name with args.
11186 set dummy $ac_prog; ac_word=$2
11187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11188 $as_echo_n "checking for $ac_word... " >&6; }
11189 if ${ac_cv_path_XARGS+:} false; then :
11190 $as_echo_n "(cached) " >&6
11191 else
11192 case $XARGS in
11193 [\\/]* | ?:[\\/]*)
11194 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11195 ;;
11196 *)
11197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11198 for as_dir in $PATH
11199 do
11200 IFS=$as_save_IFS
11201 test -z "$as_dir" && as_dir=.
11202 for ac_exec_ext in '' $ac_executable_extensions; do
11203 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11204 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11205 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11206 break 2
11207 fi
11208 done
11209 done
11210 IFS=$as_save_IFS
11211
11212 ;;
11213 esac
11214 fi
11215 XARGS=$ac_cv_path_XARGS
11216 if test -n "$XARGS"; then
11217 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11218 $as_echo "$XARGS" >&6; }
11219 else
11220 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11221 $as_echo "no" >&6; }
11222 fi
11223
11224
11225 test -n "$XARGS" && break
11226 done
11227
11228 else
11229 # The variable is set, but is it from the command line or the environment?
11230
11231 # Try to remove the string !XARGS! from our list.
11232 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11233 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11234 # If it failed, the variable was not from the command line. Ignore it,
11235 # but warn the user (except for BASH, which is always set by the calling BASH).
11236 if test "xXARGS" != xBASH; then
11237 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11238 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11239 fi
11240 # Try to locate tool using the code snippet
11241 for ac_prog in xargs
11242 do
11243 # Extract the first word of "$ac_prog", so it can be a program name with args.
11244 set dummy $ac_prog; ac_word=$2
11245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11246 $as_echo_n "checking for $ac_word... " >&6; }
11247 if ${ac_cv_path_XARGS+:} false; then :
11248 $as_echo_n "(cached) " >&6
11249 else
11250 case $XARGS in
11251 [\\/]* | ?:[\\/]*)
11252 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11253 ;;
11254 *)
11255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11256 for as_dir in $PATH
11257 do
11258 IFS=$as_save_IFS
11259 test -z "$as_dir" && as_dir=.
11260 for ac_exec_ext in '' $ac_executable_extensions; do
11261 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11262 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11263 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11264 break 2
11265 fi
11266 done
11267 done
11268 IFS=$as_save_IFS
11269
11270 ;;
11271 esac
11272 fi
11273 XARGS=$ac_cv_path_XARGS
11274 if test -n "$XARGS"; then
11275 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11276 $as_echo "$XARGS" >&6; }
11277 else
11278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11279 $as_echo "no" >&6; }
11280 fi
11281
11282
11283 test -n "$XARGS" && break
11284 done
11285
11286 else
11287 # If it succeeded, then it was overridden by the user. We will use it
11288 # for the tool.
11289
11290 # First remove it from the list of overridden variables, so we can test
11291 # for unknown variables in the end.
11292 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11293
11294 # Check if the provided tool contains a complete path.
11295 tool_specified="$XARGS"
11296 tool_basename="${tool_specified##*/}"
11297 if test "x$tool_basename" = "x$tool_specified"; then
11298 # A command without a complete path is provided, search $PATH.
11299 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11300 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11301 # Extract the first word of "$tool_basename", so it can be a program name with args.
11302 set dummy $tool_basename; ac_word=$2
11303 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11304 $as_echo_n "checking for $ac_word... " >&6; }
11305 if ${ac_cv_path_XARGS+:} false; then :
11306 $as_echo_n "(cached) " >&6
11307 else
11308 case $XARGS in
11309 [\\/]* | ?:[\\/]*)
11310 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11311 ;;
11312 *)
11313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11314 for as_dir in $PATH
11315 do
11316 IFS=$as_save_IFS
11317 test -z "$as_dir" && as_dir=.
11318 for ac_exec_ext in '' $ac_executable_extensions; do
11319 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11320 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11321 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11322 break 2
11323 fi
11324 done
11325 done
11326 IFS=$as_save_IFS
11327
11328 ;;
11329 esac
11330 fi
11331 XARGS=$ac_cv_path_XARGS
11332 if test -n "$XARGS"; then
11333 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11334 $as_echo "$XARGS" >&6; }
11335 else
11336 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11337 $as_echo "no" >&6; }
11338 fi
11339
11340
11341 if test "x$XARGS" = x; then
11342 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11343 fi
11344 else
11345 # Otherwise we believe it is a complete path. Use it as it is.
11346 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11347 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11349 $as_echo_n "checking for XARGS... " >&6; }
11350 if test ! -x "$tool_specified"; then
11351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11352 $as_echo "not found" >&6; }
11353 as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11354 fi
11355 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11356 $as_echo "$tool_specified" >&6; }
11357 fi
11358 fi
11359 fi
11360
11361
11362
11363 if test "x$XARGS" = x; then
11364 as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11365 fi
11366
11367
11368
11369 # Then required tools that require some special treatment.
11370
11371
11372 # Publish this variable in the help.
11373
11374
11375 if test "x$AWK" = x; then
11376 # The variable is not set by user, try to locate tool using the code snippet
11377 for ac_prog in gawk mawk nawk awk
11378 do
11379 # Extract the first word of "$ac_prog", so it can be a program name with args.
11380 set dummy $ac_prog; ac_word=$2
11381 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11382 $as_echo_n "checking for $ac_word... " >&6; }
11383 if ${ac_cv_prog_AWK+:} false; then :
11384 $as_echo_n "(cached) " >&6
11385 else
11386 if test -n "$AWK"; then
11387 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11388 else
11389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11390 for as_dir in $PATH
11391 do
11392 IFS=$as_save_IFS
11393 test -z "$as_dir" && as_dir=.
11394 for ac_exec_ext in '' $ac_executable_extensions; do
11395 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11396 ac_cv_prog_AWK="$ac_prog"
11397 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11398 break 2
11399 fi
11400 done
11401 done
11402 IFS=$as_save_IFS
11403
11404 fi
11405 fi
11406 AWK=$ac_cv_prog_AWK
11407 if test -n "$AWK"; then
11408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11409 $as_echo "$AWK" >&6; }
11410 else
11411 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11412 $as_echo "no" >&6; }
11413 fi
11414
11415
11416 test -n "$AWK" && break
11417 done
11418
11419 else
11420 # The variable is set, but is it from the command line or the environment?
11421
11422 # Try to remove the string !AWK! from our list.
11423 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11424 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11425 # If it failed, the variable was not from the command line. Ignore it,
11426 # but warn the user (except for BASH, which is always set by the calling BASH).
11427 if test "xAWK" != xBASH; then
11428 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11429 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11430 fi
11431 # Try to locate tool using the code snippet
11432 for ac_prog in gawk mawk nawk awk
11433 do
11434 # Extract the first word of "$ac_prog", so it can be a program name with args.
11435 set dummy $ac_prog; ac_word=$2
11436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11437 $as_echo_n "checking for $ac_word... " >&6; }
11438 if ${ac_cv_prog_AWK+:} false; then :
11439 $as_echo_n "(cached) " >&6
11440 else
11441 if test -n "$AWK"; then
11442 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11443 else
11444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11445 for as_dir in $PATH
11446 do
11447 IFS=$as_save_IFS
11448 test -z "$as_dir" && as_dir=.
11449 for ac_exec_ext in '' $ac_executable_extensions; do
11450 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11451 ac_cv_prog_AWK="$ac_prog"
11452 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11453 break 2
11454 fi
11455 done
11456 done
11457 IFS=$as_save_IFS
11458
11459 fi
11460 fi
11461 AWK=$ac_cv_prog_AWK
11462 if test -n "$AWK"; then
11463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11464 $as_echo "$AWK" >&6; }
11465 else
11466 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11467 $as_echo "no" >&6; }
11468 fi
11469
11470
11471 test -n "$AWK" && break
11472 done
11473
11474 else
11475 # If it succeeded, then it was overridden by the user. We will use it
11476 # for the tool.
11477
11478 # First remove it from the list of overridden variables, so we can test
11479 # for unknown variables in the end.
11480 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11481
11482 # Check if the provided tool contains a complete path.
11483 tool_specified="$AWK"
11484 tool_basename="${tool_specified##*/}"
11485 if test "x$tool_basename" = "x$tool_specified"; then
11486 # A command without a complete path is provided, search $PATH.
11487 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11488 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11489 # Extract the first word of "$tool_basename", so it can be a program name with args.
11490 set dummy $tool_basename; ac_word=$2
11491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11492 $as_echo_n "checking for $ac_word... " >&6; }
11493 if ${ac_cv_path_AWK+:} false; then :
11494 $as_echo_n "(cached) " >&6
11495 else
11496 case $AWK in
11497 [\\/]* | ?:[\\/]*)
11498 ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11499 ;;
11500 *)
11501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11502 for as_dir in $PATH
11503 do
11504 IFS=$as_save_IFS
11505 test -z "$as_dir" && as_dir=.
11506 for ac_exec_ext in '' $ac_executable_extensions; do
11507 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11508 ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11509 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11510 break 2
11511 fi
11512 done
11513 done
11514 IFS=$as_save_IFS
11515
11516 ;;
11517 esac
11518 fi
11519 AWK=$ac_cv_path_AWK
11520 if test -n "$AWK"; then
11521 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11522 $as_echo "$AWK" >&6; }
11523 else
11524 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11525 $as_echo "no" >&6; }
11526 fi
11527
11528
11529 if test "x$AWK" = x; then
11530 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11531 fi
11532 else
11533 # Otherwise we believe it is a complete path. Use it as it is.
11534 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11535 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11536 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11537 $as_echo_n "checking for AWK... " >&6; }
11538 if test ! -x "$tool_specified"; then
11539 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11540 $as_echo "not found" >&6; }
11541 as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11542 fi
11543 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11544 $as_echo "$tool_specified" >&6; }
11545 fi
11546 fi
11547 fi
11548
11549
11550 if test "x$AWK" = x; then
11551 as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11552 fi
11553
11554
11555
11556
11557 # Publish this variable in the help.
11558
11559
11560 if test "x$GREP" = x; then
11561 # The variable is not set by user, try to locate tool using the code snippet
11562 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11563 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11564 if ${ac_cv_path_GREP+:} false; then :
11565 $as_echo_n "(cached) " >&6
11566 else
11567 if test -z "$GREP"; then
11568 ac_path_GREP_found=false
11569 # Loop through the user's path and test for each of PROGNAME-LIST
11570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11571 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11572 do
11573 IFS=$as_save_IFS
11574 test -z "$as_dir" && as_dir=.
11575 for ac_prog in grep ggrep; do
11576 for ac_exec_ext in '' $ac_executable_extensions; do
11577 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11578 as_fn_executable_p "$ac_path_GREP" || continue
11579 # Check for GNU ac_path_GREP and select it if it is found.
11580 # Check for GNU $ac_path_GREP
11581 case `"$ac_path_GREP" --version 2>&1` in
11582 *GNU*)
11583 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11584 *)
11585 ac_count=0
11586 $as_echo_n 0123456789 >"conftest.in"
11587 while :
11588 do
11589 cat "conftest.in" "conftest.in" >"conftest.tmp"
11590 mv "conftest.tmp" "conftest.in"
11591 cp "conftest.in" "conftest.nl"
11592 $as_echo 'GREP' >> "conftest.nl"
11593 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11594 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11595 as_fn_arith $ac_count + 1 && ac_count=$as_val
11596 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11597 # Best one so far, save it but keep looking for a better one
11598 ac_cv_path_GREP="$ac_path_GREP"
11599 ac_path_GREP_max=$ac_count
11600 fi
11601 # 10*(2^10) chars as input seems more than enough
11602 test $ac_count -gt 10 && break
11603 done
11604 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11605 esac
11606
11607 $ac_path_GREP_found && break 3
11608 done
11609 done
11610 done
11611 IFS=$as_save_IFS
11612 if test -z "$ac_cv_path_GREP"; then
11613 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11614 fi
11615 else
11616 ac_cv_path_GREP=$GREP
11617 fi
11618
11619 fi
11620 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11621 $as_echo "$ac_cv_path_GREP" >&6; }
11622 GREP="$ac_cv_path_GREP"
11623
11624
11625 else
11626 # The variable is set, but is it from the command line or the environment?
11627
11628 # Try to remove the string !GREP! from our list.
11629 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11630 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11631 # If it failed, the variable was not from the command line. Ignore it,
11632 # but warn the user (except for BASH, which is always set by the calling BASH).
11633 if test "xGREP" != xBASH; then
11634 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11635 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11636 fi
11637 # Try to locate tool using the code snippet
11638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11639 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11640 if ${ac_cv_path_GREP+:} false; then :
11641 $as_echo_n "(cached) " >&6
11642 else
11643 if test -z "$GREP"; then
11644 ac_path_GREP_found=false
11645 # Loop through the user's path and test for each of PROGNAME-LIST
11646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11647 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11648 do
11649 IFS=$as_save_IFS
11650 test -z "$as_dir" && as_dir=.
11651 for ac_prog in grep ggrep; do
11652 for ac_exec_ext in '' $ac_executable_extensions; do
11653 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11654 as_fn_executable_p "$ac_path_GREP" || continue
11655 # Check for GNU ac_path_GREP and select it if it is found.
11656 # Check for GNU $ac_path_GREP
11657 case `"$ac_path_GREP" --version 2>&1` in
11658 *GNU*)
11659 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11660 *)
11661 ac_count=0
11662 $as_echo_n 0123456789 >"conftest.in"
11663 while :
11664 do
11665 cat "conftest.in" "conftest.in" >"conftest.tmp"
11666 mv "conftest.tmp" "conftest.in"
11667 cp "conftest.in" "conftest.nl"
11668 $as_echo 'GREP' >> "conftest.nl"
11669 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11670 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11671 as_fn_arith $ac_count + 1 && ac_count=$as_val
11672 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11673 # Best one so far, save it but keep looking for a better one
11674 ac_cv_path_GREP="$ac_path_GREP"
11675 ac_path_GREP_max=$ac_count
11676 fi
11677 # 10*(2^10) chars as input seems more than enough
11678 test $ac_count -gt 10 && break
11679 done
11680 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11681 esac
11682
11683 $ac_path_GREP_found && break 3
11684 done
11685 done
11686 done
11687 IFS=$as_save_IFS
11688 if test -z "$ac_cv_path_GREP"; then
11689 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11690 fi
11691 else
11692 ac_cv_path_GREP=$GREP
11693 fi
11694
11695 fi
11696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11697 $as_echo "$ac_cv_path_GREP" >&6; }
11698 GREP="$ac_cv_path_GREP"
11699
11700
11701 else
11702 # If it succeeded, then it was overridden by the user. We will use it
11703 # for the tool.
11704
11705 # First remove it from the list of overridden variables, so we can test
11706 # for unknown variables in the end.
11707 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11708
11709 # Check if the provided tool contains a complete path.
11710 tool_specified="$GREP"
11711 tool_basename="${tool_specified##*/}"
11712 if test "x$tool_basename" = "x$tool_specified"; then
11713 # A command without a complete path is provided, search $PATH.
11714 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11715 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11716 # Extract the first word of "$tool_basename", so it can be a program name with args.
11717 set dummy $tool_basename; ac_word=$2
11718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11719 $as_echo_n "checking for $ac_word... " >&6; }
11720 if ${ac_cv_path_GREP+:} false; then :
11721 $as_echo_n "(cached) " >&6
11722 else
11723 case $GREP in
11724 [\\/]* | ?:[\\/]*)
11725 ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11726 ;;
11727 *)
11728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11729 for as_dir in $PATH
11730 do
11731 IFS=$as_save_IFS
11732 test -z "$as_dir" && as_dir=.
11733 for ac_exec_ext in '' $ac_executable_extensions; do
11734 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11735 ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11736 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11737 break 2
11738 fi
11739 done
11740 done
11741 IFS=$as_save_IFS
11742
11743 ;;
11744 esac
11745 fi
11746 GREP=$ac_cv_path_GREP
11747 if test -n "$GREP"; then
11748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11749 $as_echo "$GREP" >&6; }
11750 else
11751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11752 $as_echo "no" >&6; }
11753 fi
11754
11755
11756 if test "x$GREP" = x; then
11757 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11758 fi
11759 else
11760 # Otherwise we believe it is a complete path. Use it as it is.
11761 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11762 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11763 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11764 $as_echo_n "checking for GREP... " >&6; }
11765 if test ! -x "$tool_specified"; then
11766 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11767 $as_echo "not found" >&6; }
11768 as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11769 fi
11770 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11771 $as_echo "$tool_specified" >&6; }
11772 fi
11773 fi
11774 fi
11775
11776
11777 if test "x$GREP" = x; then
11778 as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11779 fi
11780
11781
11782
11783
11784 # Publish this variable in the help.
11785
11786
11787 if test "x$EGREP" = x; then
11788 # The variable is not set by user, try to locate tool using the code snippet
11789 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11790 $as_echo_n "checking for egrep... " >&6; }
11791 if ${ac_cv_path_EGREP+:} false; then :
11792 $as_echo_n "(cached) " >&6
11793 else
11794 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11795 then ac_cv_path_EGREP="$GREP -E"
11796 else
11797 if test -z "$EGREP"; then
11798 ac_path_EGREP_found=false
11799 # Loop through the user's path and test for each of PROGNAME-LIST
11800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11801 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11802 do
11803 IFS=$as_save_IFS
11804 test -z "$as_dir" && as_dir=.
11805 for ac_prog in egrep; do
11806 for ac_exec_ext in '' $ac_executable_extensions; do
11807 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11808 as_fn_executable_p "$ac_path_EGREP" || continue
11809 # Check for GNU ac_path_EGREP and select it if it is found.
11810 # Check for GNU $ac_path_EGREP
11811 case `"$ac_path_EGREP" --version 2>&1` in
11812 *GNU*)
11813 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11814 *)
11815 ac_count=0
11816 $as_echo_n 0123456789 >"conftest.in"
11817 while :
11818 do
11819 cat "conftest.in" "conftest.in" >"conftest.tmp"
11820 mv "conftest.tmp" "conftest.in"
11821 cp "conftest.in" "conftest.nl"
11822 $as_echo 'EGREP' >> "conftest.nl"
11823 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11824 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11825 as_fn_arith $ac_count + 1 && ac_count=$as_val
11826 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11827 # Best one so far, save it but keep looking for a better one
11828 ac_cv_path_EGREP="$ac_path_EGREP"
11829 ac_path_EGREP_max=$ac_count
11830 fi
11831 # 10*(2^10) chars as input seems more than enough
11832 test $ac_count -gt 10 && break
11833 done
11834 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11835 esac
11836
11837 $ac_path_EGREP_found && break 3
11838 done
11839 done
11840 done
11841 IFS=$as_save_IFS
11842 if test -z "$ac_cv_path_EGREP"; then
11843 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11844 fi
11845 else
11846 ac_cv_path_EGREP=$EGREP
11847 fi
11848
11849 fi
11850 fi
11851 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11852 $as_echo "$ac_cv_path_EGREP" >&6; }
11853 EGREP="$ac_cv_path_EGREP"
11854
11855
11856 else
11857 # The variable is set, but is it from the command line or the environment?
11858
11859 # Try to remove the string !EGREP! from our list.
11860 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11861 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11862 # If it failed, the variable was not from the command line. Ignore it,
11863 # but warn the user (except for BASH, which is always set by the calling BASH).
11864 if test "xEGREP" != xBASH; then
11865 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11866 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11867 fi
11868 # Try to locate tool using the code snippet
11869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11870 $as_echo_n "checking for egrep... " >&6; }
11871 if ${ac_cv_path_EGREP+:} false; then :
11872 $as_echo_n "(cached) " >&6
11873 else
11874 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11875 then ac_cv_path_EGREP="$GREP -E"
11876 else
11877 if test -z "$EGREP"; then
11878 ac_path_EGREP_found=false
11879 # Loop through the user's path and test for each of PROGNAME-LIST
11880 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11881 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11882 do
11883 IFS=$as_save_IFS
11884 test -z "$as_dir" && as_dir=.
11885 for ac_prog in egrep; do
11886 for ac_exec_ext in '' $ac_executable_extensions; do
11887 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11888 as_fn_executable_p "$ac_path_EGREP" || continue
11889 # Check for GNU ac_path_EGREP and select it if it is found.
11890 # Check for GNU $ac_path_EGREP
11891 case `"$ac_path_EGREP" --version 2>&1` in
11892 *GNU*)
11893 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11894 *)
11895 ac_count=0
11896 $as_echo_n 0123456789 >"conftest.in"
11897 while :
11898 do
11899 cat "conftest.in" "conftest.in" >"conftest.tmp"
11900 mv "conftest.tmp" "conftest.in"
11901 cp "conftest.in" "conftest.nl"
11902 $as_echo 'EGREP' >> "conftest.nl"
11903 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11904 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11905 as_fn_arith $ac_count + 1 && ac_count=$as_val
11906 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11907 # Best one so far, save it but keep looking for a better one
11908 ac_cv_path_EGREP="$ac_path_EGREP"
11909 ac_path_EGREP_max=$ac_count
11910 fi
11911 # 10*(2^10) chars as input seems more than enough
11912 test $ac_count -gt 10 && break
11913 done
11914 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11915 esac
11916
11917 $ac_path_EGREP_found && break 3
11918 done
11919 done
11920 done
11921 IFS=$as_save_IFS
11922 if test -z "$ac_cv_path_EGREP"; then
11923 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11924 fi
11925 else
11926 ac_cv_path_EGREP=$EGREP
11927 fi
11928
11929 fi
11930 fi
11931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11932 $as_echo "$ac_cv_path_EGREP" >&6; }
11933 EGREP="$ac_cv_path_EGREP"
11934
11935
11936 else
11937 # If it succeeded, then it was overridden by the user. We will use it
11938 # for the tool.
11939
11940 # First remove it from the list of overridden variables, so we can test
11941 # for unknown variables in the end.
11942 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11943
11944 # Check if the provided tool contains a complete path.
11945 tool_specified="$EGREP"
11946 tool_basename="${tool_specified##*/}"
11947 if test "x$tool_basename" = "x$tool_specified"; then
11948 # A command without a complete path is provided, search $PATH.
11949 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11950 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11951 # Extract the first word of "$tool_basename", so it can be a program name with args.
11952 set dummy $tool_basename; ac_word=$2
11953 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11954 $as_echo_n "checking for $ac_word... " >&6; }
11955 if ${ac_cv_path_EGREP+:} false; then :
11956 $as_echo_n "(cached) " >&6
11957 else
11958 case $EGREP in
11959 [\\/]* | ?:[\\/]*)
11960 ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11961 ;;
11962 *)
11963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11964 for as_dir in $PATH
11965 do
11966 IFS=$as_save_IFS
11967 test -z "$as_dir" && as_dir=.
11968 for ac_exec_ext in '' $ac_executable_extensions; do
11969 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11970 ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11971 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11972 break 2
11973 fi
11974 done
11975 done
11976 IFS=$as_save_IFS
11977
11978 ;;
11979 esac
11980 fi
11981 EGREP=$ac_cv_path_EGREP
11982 if test -n "$EGREP"; then
11983 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11984 $as_echo "$EGREP" >&6; }
11985 else
11986 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11987 $as_echo "no" >&6; }
11988 fi
11989
11990
11991 if test "x$EGREP" = x; then
11992 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11993 fi
11994 else
11995 # Otherwise we believe it is a complete path. Use it as it is.
11996 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11997 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11999 $as_echo_n "checking for EGREP... " >&6; }
12000 if test ! -x "$tool_specified"; then
12001 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12002 $as_echo "not found" >&6; }
12003 as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12004 fi
12005 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12006 $as_echo "$tool_specified" >&6; }
12007 fi
12008 fi
12009 fi
12010
12011
12012 if test "x$EGREP" = x; then
12013 as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12014 fi
12015
12016
12017
12018
12019 # Publish this variable in the help.
12020
12021
12022 if test "x$FGREP" = x; then
12023 # The variable is not set by user, try to locate tool using the code snippet
12024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12025 $as_echo_n "checking for fgrep... " >&6; }
12026 if ${ac_cv_path_FGREP+:} false; then :
12027 $as_echo_n "(cached) " >&6
12028 else
12029 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12030 then ac_cv_path_FGREP="$GREP -F"
12031 else
12032 if test -z "$FGREP"; then
12033 ac_path_FGREP_found=false
12034 # Loop through the user's path and test for each of PROGNAME-LIST
12035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12036 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12037 do
12038 IFS=$as_save_IFS
12039 test -z "$as_dir" && as_dir=.
12040 for ac_prog in fgrep; do
12041 for ac_exec_ext in '' $ac_executable_extensions; do
12042 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12043 as_fn_executable_p "$ac_path_FGREP" || continue
12044 # Check for GNU ac_path_FGREP and select it if it is found.
12045 # Check for GNU $ac_path_FGREP
12046 case `"$ac_path_FGREP" --version 2>&1` in
12047 *GNU*)
12048 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12049 *)
12050 ac_count=0
12051 $as_echo_n 0123456789 >"conftest.in"
12052 while :
12053 do
12054 cat "conftest.in" "conftest.in" >"conftest.tmp"
12055 mv "conftest.tmp" "conftest.in"
12056 cp "conftest.in" "conftest.nl"
12057 $as_echo 'FGREP' >> "conftest.nl"
12058 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12059 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12060 as_fn_arith $ac_count + 1 && ac_count=$as_val
12061 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12062 # Best one so far, save it but keep looking for a better one
12063 ac_cv_path_FGREP="$ac_path_FGREP"
12064 ac_path_FGREP_max=$ac_count
12065 fi
12066 # 10*(2^10) chars as input seems more than enough
12067 test $ac_count -gt 10 && break
12068 done
12069 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12070 esac
12071
12072 $ac_path_FGREP_found && break 3
12073 done
12074 done
12075 done
12076 IFS=$as_save_IFS
12077 if test -z "$ac_cv_path_FGREP"; then
12078 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12079 fi
12080 else
12081 ac_cv_path_FGREP=$FGREP
12082 fi
12083
12084 fi
12085 fi
12086 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12087 $as_echo "$ac_cv_path_FGREP" >&6; }
12088 FGREP="$ac_cv_path_FGREP"
12089
12090
12091 else
12092 # The variable is set, but is it from the command line or the environment?
12093
12094 # Try to remove the string !FGREP! from our list.
12095 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12096 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12097 # If it failed, the variable was not from the command line. Ignore it,
12098 # but warn the user (except for BASH, which is always set by the calling BASH).
12099 if test "xFGREP" != xBASH; then
12100 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12101 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12102 fi
12103 # Try to locate tool using the code snippet
12104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12105 $as_echo_n "checking for fgrep... " >&6; }
12106 if ${ac_cv_path_FGREP+:} false; then :
12107 $as_echo_n "(cached) " >&6
12108 else
12109 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12110 then ac_cv_path_FGREP="$GREP -F"
12111 else
12112 if test -z "$FGREP"; then
12113 ac_path_FGREP_found=false
12114 # Loop through the user's path and test for each of PROGNAME-LIST
12115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12116 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12117 do
12118 IFS=$as_save_IFS
12119 test -z "$as_dir" && as_dir=.
12120 for ac_prog in fgrep; do
12121 for ac_exec_ext in '' $ac_executable_extensions; do
12122 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12123 as_fn_executable_p "$ac_path_FGREP" || continue
12124 # Check for GNU ac_path_FGREP and select it if it is found.
12125 # Check for GNU $ac_path_FGREP
12126 case `"$ac_path_FGREP" --version 2>&1` in
12127 *GNU*)
12128 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12129 *)
12130 ac_count=0
12131 $as_echo_n 0123456789 >"conftest.in"
12132 while :
12133 do
12134 cat "conftest.in" "conftest.in" >"conftest.tmp"
12135 mv "conftest.tmp" "conftest.in"
12136 cp "conftest.in" "conftest.nl"
12137 $as_echo 'FGREP' >> "conftest.nl"
12138 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12139 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12140 as_fn_arith $ac_count + 1 && ac_count=$as_val
12141 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12142 # Best one so far, save it but keep looking for a better one
12143 ac_cv_path_FGREP="$ac_path_FGREP"
12144 ac_path_FGREP_max=$ac_count
12145 fi
12146 # 10*(2^10) chars as input seems more than enough
12147 test $ac_count -gt 10 && break
12148 done
12149 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12150 esac
12151
12152 $ac_path_FGREP_found && break 3
12153 done
12154 done
12155 done
12156 IFS=$as_save_IFS
12157 if test -z "$ac_cv_path_FGREP"; then
12158 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12159 fi
12160 else
12161 ac_cv_path_FGREP=$FGREP
12162 fi
12163
12164 fi
12165 fi
12166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12167 $as_echo "$ac_cv_path_FGREP" >&6; }
12168 FGREP="$ac_cv_path_FGREP"
12169
12170
12171 else
12172 # If it succeeded, then it was overridden by the user. We will use it
12173 # for the tool.
12174
12175 # First remove it from the list of overridden variables, so we can test
12176 # for unknown variables in the end.
12177 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12178
12179 # Check if the provided tool contains a complete path.
12180 tool_specified="$FGREP"
12181 tool_basename="${tool_specified##*/}"
12182 if test "x$tool_basename" = "x$tool_specified"; then
12183 # A command without a complete path is provided, search $PATH.
12184 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12185 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12186 # Extract the first word of "$tool_basename", so it can be a program name with args.
12187 set dummy $tool_basename; ac_word=$2
12188 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12189 $as_echo_n "checking for $ac_word... " >&6; }
12190 if ${ac_cv_path_FGREP+:} false; then :
12191 $as_echo_n "(cached) " >&6
12192 else
12193 case $FGREP in
12194 [\\/]* | ?:[\\/]*)
12195 ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12196 ;;
12197 *)
12198 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12199 for as_dir in $PATH
12200 do
12201 IFS=$as_save_IFS
12202 test -z "$as_dir" && as_dir=.
12203 for ac_exec_ext in '' $ac_executable_extensions; do
12204 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12205 ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12206 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12207 break 2
12208 fi
12209 done
12210 done
12211 IFS=$as_save_IFS
12212
12213 ;;
12214 esac
12215 fi
12216 FGREP=$ac_cv_path_FGREP
12217 if test -n "$FGREP"; then
12218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12219 $as_echo "$FGREP" >&6; }
12220 else
12221 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12222 $as_echo "no" >&6; }
12223 fi
12224
12225
12226 if test "x$FGREP" = x; then
12227 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12228 fi
12229 else
12230 # Otherwise we believe it is a complete path. Use it as it is.
12231 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12232 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12233 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12234 $as_echo_n "checking for FGREP... " >&6; }
12235 if test ! -x "$tool_specified"; then
12236 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12237 $as_echo "not found" >&6; }
12238 as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12239 fi
12240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12241 $as_echo "$tool_specified" >&6; }
12242 fi
12243 fi
12244 fi
12245
12246
12247 if test "x$FGREP" = x; then
12248 as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12249 fi
12250
12251
12252
12253
12254 # Publish this variable in the help.
12255
12256
12257 if test "x$SED" = x; then
12258 # The variable is not set by user, try to locate tool using the code snippet
12259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12260 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12261 if ${ac_cv_path_SED+:} false; then :
12262 $as_echo_n "(cached) " >&6
12263 else
12264 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12265 for ac_i in 1 2 3 4 5 6 7; do
12266 ac_script="$ac_script$as_nl$ac_script"
12267 done
12268 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12269 { ac_script=; unset ac_script;}
12270 if test -z "$SED"; then
12271 ac_path_SED_found=false
12272 # Loop through the user's path and test for each of PROGNAME-LIST
12273 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12274 for as_dir in $PATH
12275 do
12276 IFS=$as_save_IFS
12277 test -z "$as_dir" && as_dir=.
12278 for ac_prog in sed gsed; do
12279 for ac_exec_ext in '' $ac_executable_extensions; do
12280 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12281 as_fn_executable_p "$ac_path_SED" || continue
12282 # Check for GNU ac_path_SED and select it if it is found.
12283 # Check for GNU $ac_path_SED
12284 case `"$ac_path_SED" --version 2>&1` in
12285 *GNU*)
12286 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12287 *)
12288 ac_count=0
12289 $as_echo_n 0123456789 >"conftest.in"
12290 while :
12291 do
12292 cat "conftest.in" "conftest.in" >"conftest.tmp"
12293 mv "conftest.tmp" "conftest.in"
12294 cp "conftest.in" "conftest.nl"
12295 $as_echo '' >> "conftest.nl"
12296 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12297 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12298 as_fn_arith $ac_count + 1 && ac_count=$as_val
12299 if test $ac_count -gt ${ac_path_SED_max-0}; then
12300 # Best one so far, save it but keep looking for a better one
12301 ac_cv_path_SED="$ac_path_SED"
12302 ac_path_SED_max=$ac_count
12303 fi
12304 # 10*(2^10) chars as input seems more than enough
12305 test $ac_count -gt 10 && break
12306 done
12307 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12308 esac
12309
12310 $ac_path_SED_found && break 3
12311 done
12312 done
12313 done
12314 IFS=$as_save_IFS
12315 if test -z "$ac_cv_path_SED"; then
12316 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12317 fi
12318 else
12319 ac_cv_path_SED=$SED
12320 fi
12321
12322 fi
12323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12324 $as_echo "$ac_cv_path_SED" >&6; }
12325 SED="$ac_cv_path_SED"
12326 rm -f conftest.sed
12327
12328 else
12329 # The variable is set, but is it from the command line or the environment?
12330
12331 # Try to remove the string !SED! from our list.
12332 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12333 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12334 # If it failed, the variable was not from the command line. Ignore it,
12335 # but warn the user (except for BASH, which is always set by the calling BASH).
12336 if test "xSED" != xBASH; then
12337 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12338 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12339 fi
12340 # Try to locate tool using the code snippet
12341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12342 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12343 if ${ac_cv_path_SED+:} false; then :
12344 $as_echo_n "(cached) " >&6
12345 else
12346 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12347 for ac_i in 1 2 3 4 5 6 7; do
12348 ac_script="$ac_script$as_nl$ac_script"
12349 done
12350 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12351 { ac_script=; unset ac_script;}
12352 if test -z "$SED"; then
12353 ac_path_SED_found=false
12354 # Loop through the user's path and test for each of PROGNAME-LIST
12355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12356 for as_dir in $PATH
12357 do
12358 IFS=$as_save_IFS
12359 test -z "$as_dir" && as_dir=.
12360 for ac_prog in sed gsed; do
12361 for ac_exec_ext in '' $ac_executable_extensions; do
12362 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12363 as_fn_executable_p "$ac_path_SED" || continue
12364 # Check for GNU ac_path_SED and select it if it is found.
12365 # Check for GNU $ac_path_SED
12366 case `"$ac_path_SED" --version 2>&1` in
12367 *GNU*)
12368 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12369 *)
12370 ac_count=0
12371 $as_echo_n 0123456789 >"conftest.in"
12372 while :
12373 do
12374 cat "conftest.in" "conftest.in" >"conftest.tmp"
12375 mv "conftest.tmp" "conftest.in"
12376 cp "conftest.in" "conftest.nl"
12377 $as_echo '' >> "conftest.nl"
12378 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12379 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12380 as_fn_arith $ac_count + 1 && ac_count=$as_val
12381 if test $ac_count -gt ${ac_path_SED_max-0}; then
12382 # Best one so far, save it but keep looking for a better one
12383 ac_cv_path_SED="$ac_path_SED"
12384 ac_path_SED_max=$ac_count
12385 fi
12386 # 10*(2^10) chars as input seems more than enough
12387 test $ac_count -gt 10 && break
12388 done
12389 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12390 esac
12391
12392 $ac_path_SED_found && break 3
12393 done
12394 done
12395 done
12396 IFS=$as_save_IFS
12397 if test -z "$ac_cv_path_SED"; then
12398 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12399 fi
12400 else
12401 ac_cv_path_SED=$SED
12402 fi
12403
12404 fi
12405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12406 $as_echo "$ac_cv_path_SED" >&6; }
12407 SED="$ac_cv_path_SED"
12408 rm -f conftest.sed
12409
12410 else
12411 # If it succeeded, then it was overridden by the user. We will use it
12412 # for the tool.
12413
12414 # First remove it from the list of overridden variables, so we can test
12415 # for unknown variables in the end.
12416 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12417
12418 # Check if the provided tool contains a complete path.
12419 tool_specified="$SED"
12420 tool_basename="${tool_specified##*/}"
12421 if test "x$tool_basename" = "x$tool_specified"; then
12422 # A command without a complete path is provided, search $PATH.
12423 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12424 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12425 # Extract the first word of "$tool_basename", so it can be a program name with args.
12426 set dummy $tool_basename; ac_word=$2
12427 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12428 $as_echo_n "checking for $ac_word... " >&6; }
12429 if ${ac_cv_path_SED+:} false; then :
12430 $as_echo_n "(cached) " >&6
12431 else
12432 case $SED in
12433 [\\/]* | ?:[\\/]*)
12434 ac_cv_path_SED="$SED" # Let the user override the test with a path.
12435 ;;
12436 *)
12437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12438 for as_dir in $PATH
12439 do
12440 IFS=$as_save_IFS
12441 test -z "$as_dir" && as_dir=.
12442 for ac_exec_ext in '' $ac_executable_extensions; do
12443 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12444 ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12445 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12446 break 2
12447 fi
12448 done
12449 done
12450 IFS=$as_save_IFS
12451
12452 ;;
12453 esac
12454 fi
12455 SED=$ac_cv_path_SED
12456 if test -n "$SED"; then
12457 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12458 $as_echo "$SED" >&6; }
12459 else
12460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12461 $as_echo "no" >&6; }
12462 fi
12463
12464
12465 if test "x$SED" = x; then
12466 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12467 fi
12468 else
12469 # Otherwise we believe it is a complete path. Use it as it is.
12470 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12471 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12473 $as_echo_n "checking for SED... " >&6; }
12474 if test ! -x "$tool_specified"; then
12475 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12476 $as_echo "not found" >&6; }
12477 as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12478 fi
12479 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12480 $as_echo "$tool_specified" >&6; }
12481 fi
12482 fi
12483 fi
12484
12485
12486 if test "x$SED" = x; then
12487 as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12488 fi
12489
12490
12491
12492 # Always force rm.
12493 RM="$RM -f"
12494
12495 # pwd behaves differently on various platforms and some don't support the -L flag.
12496 # Always use the bash builtin pwd to get uniform behavior.
12497 THEPWDCMD=pwd
12498
12499 # These are not required on all platforms
12500
12501
12502 # Publish this variable in the help.
12503
12504
12505 if test "x$CYGPATH" = x; then
12506 # The variable is not set by user, try to locate tool using the code snippet
12507 for ac_prog in cygpath
12508 do
12509 # Extract the first word of "$ac_prog", so it can be a program name with args.
12510 set dummy $ac_prog; ac_word=$2
12511 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12512 $as_echo_n "checking for $ac_word... " >&6; }
12513 if ${ac_cv_path_CYGPATH+:} false; then :
12514 $as_echo_n "(cached) " >&6
12515 else
12516 case $CYGPATH in
12517 [\\/]* | ?:[\\/]*)
12518 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12519 ;;
12520 *)
12521 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12522 for as_dir in $PATH
12523 do
12524 IFS=$as_save_IFS
12525 test -z "$as_dir" && as_dir=.
12526 for ac_exec_ext in '' $ac_executable_extensions; do
12527 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12528 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12529 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12530 break 2
12531 fi
12532 done
12533 done
12534 IFS=$as_save_IFS
12535
12536 ;;
12537 esac
12538 fi
12539 CYGPATH=$ac_cv_path_CYGPATH
12540 if test -n "$CYGPATH"; then
12541 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12542 $as_echo "$CYGPATH" >&6; }
12543 else
12544 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12545 $as_echo "no" >&6; }
12546 fi
12547
12548
12549 test -n "$CYGPATH" && break
12550 done
12551
12552 else
12553 # The variable is set, but is it from the command line or the environment?
12554
12555 # Try to remove the string !CYGPATH! from our list.
12556 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12557 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12558 # If it failed, the variable was not from the command line. Ignore it,
12559 # but warn the user (except for BASH, which is always set by the calling BASH).
12560 if test "xCYGPATH" != xBASH; then
12561 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12562 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12563 fi
12564 # Try to locate tool using the code snippet
12565 for ac_prog in cygpath
12566 do
12567 # Extract the first word of "$ac_prog", so it can be a program name with args.
12568 set dummy $ac_prog; ac_word=$2
12569 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12570 $as_echo_n "checking for $ac_word... " >&6; }
12571 if ${ac_cv_path_CYGPATH+:} false; then :
12572 $as_echo_n "(cached) " >&6
12573 else
12574 case $CYGPATH in
12575 [\\/]* | ?:[\\/]*)
12576 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12577 ;;
12578 *)
12579 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12580 for as_dir in $PATH
12581 do
12582 IFS=$as_save_IFS
12583 test -z "$as_dir" && as_dir=.
12584 for ac_exec_ext in '' $ac_executable_extensions; do
12585 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12586 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12587 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12588 break 2
12589 fi
12590 done
12591 done
12592 IFS=$as_save_IFS
12593
12594 ;;
12595 esac
12596 fi
12597 CYGPATH=$ac_cv_path_CYGPATH
12598 if test -n "$CYGPATH"; then
12599 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12600 $as_echo "$CYGPATH" >&6; }
12601 else
12602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12603 $as_echo "no" >&6; }
12604 fi
12605
12606
12607 test -n "$CYGPATH" && break
12608 done
12609
12610 else
12611 # If it succeeded, then it was overridden by the user. We will use it
12612 # for the tool.
12613
12614 # First remove it from the list of overridden variables, so we can test
12615 # for unknown variables in the end.
12616 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12617
12618 # Check if the provided tool contains a complete path.
12619 tool_specified="$CYGPATH"
12620 tool_basename="${tool_specified##*/}"
12621 if test "x$tool_basename" = "x$tool_specified"; then
12622 # A command without a complete path is provided, search $PATH.
12623 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12624 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12625 # Extract the first word of "$tool_basename", so it can be a program name with args.
12626 set dummy $tool_basename; ac_word=$2
12627 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12628 $as_echo_n "checking for $ac_word... " >&6; }
12629 if ${ac_cv_path_CYGPATH+:} false; then :
12630 $as_echo_n "(cached) " >&6
12631 else
12632 case $CYGPATH in
12633 [\\/]* | ?:[\\/]*)
12634 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12635 ;;
12636 *)
12637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12638 for as_dir in $PATH
12639 do
12640 IFS=$as_save_IFS
12641 test -z "$as_dir" && as_dir=.
12642 for ac_exec_ext in '' $ac_executable_extensions; do
12643 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12644 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12645 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12646 break 2
12647 fi
12648 done
12649 done
12650 IFS=$as_save_IFS
12651
12652 ;;
12653 esac
12654 fi
12655 CYGPATH=$ac_cv_path_CYGPATH
12656 if test -n "$CYGPATH"; then
12657 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12658 $as_echo "$CYGPATH" >&6; }
12659 else
12660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12661 $as_echo "no" >&6; }
12662 fi
12663
12664
12665 if test "x$CYGPATH" = x; then
12666 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12667 fi
12668 else
12669 # Otherwise we believe it is a complete path. Use it as it is.
12670 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12671 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12672 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12673 $as_echo_n "checking for CYGPATH... " >&6; }
12674 if test ! -x "$tool_specified"; then
12675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12676 $as_echo "not found" >&6; }
12677 as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12678 fi
12679 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12680 $as_echo "$tool_specified" >&6; }
12681 fi
12682 fi
12683 fi
12684
12685
12686
12687
12688 # Publish this variable in the help.
12689
12690
12691 if test "x$READLINK" = x; then
12692 # The variable is not set by user, try to locate tool using the code snippet
12693 for ac_prog in greadlink readlink
12694 do
12695 # Extract the first word of "$ac_prog", so it can be a program name with args.
12696 set dummy $ac_prog; ac_word=$2
12697 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12698 $as_echo_n "checking for $ac_word... " >&6; }
12699 if ${ac_cv_path_READLINK+:} false; then :
12700 $as_echo_n "(cached) " >&6
12701 else
12702 case $READLINK in
12703 [\\/]* | ?:[\\/]*)
12704 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12705 ;;
12706 *)
12707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12708 for as_dir in $PATH
12709 do
12710 IFS=$as_save_IFS
12711 test -z "$as_dir" && as_dir=.
12712 for ac_exec_ext in '' $ac_executable_extensions; do
12713 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12714 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12715 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12716 break 2
12717 fi
12718 done
12719 done
12720 IFS=$as_save_IFS
12721
12722 ;;
12723 esac
12724 fi
12725 READLINK=$ac_cv_path_READLINK
12726 if test -n "$READLINK"; then
12727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12728 $as_echo "$READLINK" >&6; }
12729 else
12730 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12731 $as_echo "no" >&6; }
12732 fi
12733
12734
12735 test -n "$READLINK" && break
12736 done
12737
12738 else
12739 # The variable is set, but is it from the command line or the environment?
12740
12741 # Try to remove the string !READLINK! from our list.
12742 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12743 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12744 # If it failed, the variable was not from the command line. Ignore it,
12745 # but warn the user (except for BASH, which is always set by the calling BASH).
12746 if test "xREADLINK" != xBASH; then
12747 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12748 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12749 fi
12750 # Try to locate tool using the code snippet
12751 for ac_prog in greadlink readlink
12752 do
12753 # Extract the first word of "$ac_prog", so it can be a program name with args.
12754 set dummy $ac_prog; ac_word=$2
12755 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12756 $as_echo_n "checking for $ac_word... " >&6; }
12757 if ${ac_cv_path_READLINK+:} false; then :
12758 $as_echo_n "(cached) " >&6
12759 else
12760 case $READLINK in
12761 [\\/]* | ?:[\\/]*)
12762 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12763 ;;
12764 *)
12765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12766 for as_dir in $PATH
12767 do
12768 IFS=$as_save_IFS
12769 test -z "$as_dir" && as_dir=.
12770 for ac_exec_ext in '' $ac_executable_extensions; do
12771 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12772 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12773 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12774 break 2
12775 fi
12776 done
12777 done
12778 IFS=$as_save_IFS
12779
12780 ;;
12781 esac
12782 fi
12783 READLINK=$ac_cv_path_READLINK
12784 if test -n "$READLINK"; then
12785 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12786 $as_echo "$READLINK" >&6; }
12787 else
12788 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12789 $as_echo "no" >&6; }
12790 fi
12791
12792
12793 test -n "$READLINK" && break
12794 done
12795
12796 else
12797 # If it succeeded, then it was overridden by the user. We will use it
12798 # for the tool.
12799
12800 # First remove it from the list of overridden variables, so we can test
12801 # for unknown variables in the end.
12802 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12803
12804 # Check if the provided tool contains a complete path.
12805 tool_specified="$READLINK"
12806 tool_basename="${tool_specified##*/}"
12807 if test "x$tool_basename" = "x$tool_specified"; then
12808 # A command without a complete path is provided, search $PATH.
12809 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12810 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12811 # Extract the first word of "$tool_basename", so it can be a program name with args.
12812 set dummy $tool_basename; ac_word=$2
12813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12814 $as_echo_n "checking for $ac_word... " >&6; }
12815 if ${ac_cv_path_READLINK+:} false; then :
12816 $as_echo_n "(cached) " >&6
12817 else
12818 case $READLINK in
12819 [\\/]* | ?:[\\/]*)
12820 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12821 ;;
12822 *)
12823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12824 for as_dir in $PATH
12825 do
12826 IFS=$as_save_IFS
12827 test -z "$as_dir" && as_dir=.
12828 for ac_exec_ext in '' $ac_executable_extensions; do
12829 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12830 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12831 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12832 break 2
12833 fi
12834 done
12835 done
12836 IFS=$as_save_IFS
12837
12838 ;;
12839 esac
12840 fi
12841 READLINK=$ac_cv_path_READLINK
12842 if test -n "$READLINK"; then
12843 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12844 $as_echo "$READLINK" >&6; }
12845 else
12846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12847 $as_echo "no" >&6; }
12848 fi
12849
12850
12851 if test "x$READLINK" = x; then
12852 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12853 fi
12854 else
12855 # Otherwise we believe it is a complete path. Use it as it is.
12856 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12857 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12859 $as_echo_n "checking for READLINK... " >&6; }
12860 if test ! -x "$tool_specified"; then
12861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12862 $as_echo "not found" >&6; }
12863 as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12864 fi
12865 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12866 $as_echo "$tool_specified" >&6; }
12867 fi
12868 fi
12869 fi
12870
12871
12872
12873
12874 # Publish this variable in the help.
12875
12876
12877 if test "x$DF" = x; then
12878 # The variable is not set by user, try to locate tool using the code snippet
12879 for ac_prog in df
12880 do
12881 # Extract the first word of "$ac_prog", so it can be a program name with args.
12882 set dummy $ac_prog; ac_word=$2
12883 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12884 $as_echo_n "checking for $ac_word... " >&6; }
12885 if ${ac_cv_path_DF+:} false; then :
12886 $as_echo_n "(cached) " >&6
12887 else
12888 case $DF in
12889 [\\/]* | ?:[\\/]*)
12890 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12891 ;;
12892 *)
12893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12894 for as_dir in $PATH
12895 do
12896 IFS=$as_save_IFS
12897 test -z "$as_dir" && as_dir=.
12898 for ac_exec_ext in '' $ac_executable_extensions; do
12899 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12900 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12901 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12902 break 2
12903 fi
12904 done
12905 done
12906 IFS=$as_save_IFS
12907
12908 ;;
12909 esac
12910 fi
12911 DF=$ac_cv_path_DF
12912 if test -n "$DF"; then
12913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12914 $as_echo "$DF" >&6; }
12915 else
12916 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12917 $as_echo "no" >&6; }
12918 fi
12919
12920
12921 test -n "$DF" && break
12922 done
12923
12924 else
12925 # The variable is set, but is it from the command line or the environment?
12926
12927 # Try to remove the string !DF! from our list.
12928 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12929 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12930 # If it failed, the variable was not from the command line. Ignore it,
12931 # but warn the user (except for BASH, which is always set by the calling BASH).
12932 if test "xDF" != xBASH; then
12933 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12934 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12935 fi
12936 # Try to locate tool using the code snippet
12937 for ac_prog in df
12938 do
12939 # Extract the first word of "$ac_prog", so it can be a program name with args.
12940 set dummy $ac_prog; ac_word=$2
12941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12942 $as_echo_n "checking for $ac_word... " >&6; }
12943 if ${ac_cv_path_DF+:} false; then :
12944 $as_echo_n "(cached) " >&6
12945 else
12946 case $DF in
12947 [\\/]* | ?:[\\/]*)
12948 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12949 ;;
12950 *)
12951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12952 for as_dir in $PATH
12953 do
12954 IFS=$as_save_IFS
12955 test -z "$as_dir" && as_dir=.
12956 for ac_exec_ext in '' $ac_executable_extensions; do
12957 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12958 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12959 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12960 break 2
12961 fi
12962 done
12963 done
12964 IFS=$as_save_IFS
12965
12966 ;;
12967 esac
12968 fi
12969 DF=$ac_cv_path_DF
12970 if test -n "$DF"; then
12971 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12972 $as_echo "$DF" >&6; }
12973 else
12974 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12975 $as_echo "no" >&6; }
12976 fi
12977
12978
12979 test -n "$DF" && break
12980 done
12981
12982 else
12983 # If it succeeded, then it was overridden by the user. We will use it
12984 # for the tool.
12985
12986 # First remove it from the list of overridden variables, so we can test
12987 # for unknown variables in the end.
12988 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12989
12990 # Check if the provided tool contains a complete path.
12991 tool_specified="$DF"
12992 tool_basename="${tool_specified##*/}"
12993 if test "x$tool_basename" = "x$tool_specified"; then
12994 # A command without a complete path is provided, search $PATH.
12995 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12996 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12997 # Extract the first word of "$tool_basename", so it can be a program name with args.
12998 set dummy $tool_basename; ac_word=$2
12999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13000 $as_echo_n "checking for $ac_word... " >&6; }
13001 if ${ac_cv_path_DF+:} false; then :
13002 $as_echo_n "(cached) " >&6
13003 else
13004 case $DF in
13005 [\\/]* | ?:[\\/]*)
13006 ac_cv_path_DF="$DF" # Let the user override the test with a path.
13007 ;;
13008 *)
13009 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13010 for as_dir in $PATH
13011 do
13012 IFS=$as_save_IFS
13013 test -z "$as_dir" && as_dir=.
13014 for ac_exec_ext in '' $ac_executable_extensions; do
13015 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13016 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13017 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13018 break 2
13019 fi
13020 done
13021 done
13022 IFS=$as_save_IFS
13023
13024 ;;
13025 esac
13026 fi
13027 DF=$ac_cv_path_DF
13028 if test -n "$DF"; then
13029 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13030 $as_echo "$DF" >&6; }
13031 else
13032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13033 $as_echo "no" >&6; }
13034 fi
13035
13036
13037 if test "x$DF" = x; then
13038 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13039 fi
13040 else
13041 # Otherwise we believe it is a complete path. Use it as it is.
13042 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13043 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13045 $as_echo_n "checking for DF... " >&6; }
13046 if test ! -x "$tool_specified"; then
13047 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13048 $as_echo "not found" >&6; }
13049 as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13050 fi
13051 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13052 $as_echo "$tool_specified" >&6; }
13053 fi
13054 fi
13055 fi
13056
13057
13058
13059
13060 # Publish this variable in the help.
13061
13062
13063 if test "x$SETFILE" = x; then
13064 # The variable is not set by user, try to locate tool using the code snippet
13065 for ac_prog in SetFile
13066 do
13067 # Extract the first word of "$ac_prog", so it can be a program name with args.
13068 set dummy $ac_prog; ac_word=$2
13069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13070 $as_echo_n "checking for $ac_word... " >&6; }
13071 if ${ac_cv_path_SETFILE+:} false; then :
13072 $as_echo_n "(cached) " >&6
13073 else
13074 case $SETFILE in
13075 [\\/]* | ?:[\\/]*)
13076 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13077 ;;
13078 *)
13079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13080 for as_dir in $PATH
13081 do
13082 IFS=$as_save_IFS
13083 test -z "$as_dir" && as_dir=.
13084 for ac_exec_ext in '' $ac_executable_extensions; do
13085 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13086 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13087 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13088 break 2
13089 fi
13090 done
13091 done
13092 IFS=$as_save_IFS
13093
13094 ;;
13095 esac
13096 fi
13097 SETFILE=$ac_cv_path_SETFILE
13098 if test -n "$SETFILE"; then
13099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13100 $as_echo "$SETFILE" >&6; }
13101 else
13102 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13103 $as_echo "no" >&6; }
13104 fi
13105
13106
13107 test -n "$SETFILE" && break
13108 done
13109
13110 else
13111 # The variable is set, but is it from the command line or the environment?
13112
13113 # Try to remove the string !SETFILE! from our list.
13114 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13115 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13116 # If it failed, the variable was not from the command line. Ignore it,
13117 # but warn the user (except for BASH, which is always set by the calling BASH).
13118 if test "xSETFILE" != xBASH; then
13119 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13120 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13121 fi
13122 # Try to locate tool using the code snippet
13123 for ac_prog in SetFile
13124 do
13125 # Extract the first word of "$ac_prog", so it can be a program name with args.
13126 set dummy $ac_prog; ac_word=$2
13127 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13128 $as_echo_n "checking for $ac_word... " >&6; }
13129 if ${ac_cv_path_SETFILE+:} false; then :
13130 $as_echo_n "(cached) " >&6
13131 else
13132 case $SETFILE in
13133 [\\/]* | ?:[\\/]*)
13134 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13135 ;;
13136 *)
13137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13138 for as_dir in $PATH
13139 do
13140 IFS=$as_save_IFS
13141 test -z "$as_dir" && as_dir=.
13142 for ac_exec_ext in '' $ac_executable_extensions; do
13143 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13144 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13145 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13146 break 2
13147 fi
13148 done
13149 done
13150 IFS=$as_save_IFS
13151
13152 ;;
13153 esac
13154 fi
13155 SETFILE=$ac_cv_path_SETFILE
13156 if test -n "$SETFILE"; then
13157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13158 $as_echo "$SETFILE" >&6; }
13159 else
13160 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13161 $as_echo "no" >&6; }
13162 fi
13163
13164
13165 test -n "$SETFILE" && break
13166 done
13167
13168 else
13169 # If it succeeded, then it was overridden by the user. We will use it
13170 # for the tool.
13171
13172 # First remove it from the list of overridden variables, so we can test
13173 # for unknown variables in the end.
13174 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13175
13176 # Check if the provided tool contains a complete path.
13177 tool_specified="$SETFILE"
13178 tool_basename="${tool_specified##*/}"
13179 if test "x$tool_basename" = "x$tool_specified"; then
13180 # A command without a complete path is provided, search $PATH.
13181 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13182 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13183 # Extract the first word of "$tool_basename", so it can be a program name with args.
13184 set dummy $tool_basename; ac_word=$2
13185 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13186 $as_echo_n "checking for $ac_word... " >&6; }
13187 if ${ac_cv_path_SETFILE+:} false; then :
13188 $as_echo_n "(cached) " >&6
13189 else
13190 case $SETFILE in
13191 [\\/]* | ?:[\\/]*)
13192 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13193 ;;
13194 *)
13195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13196 for as_dir in $PATH
13197 do
13198 IFS=$as_save_IFS
13199 test -z "$as_dir" && as_dir=.
13200 for ac_exec_ext in '' $ac_executable_extensions; do
13201 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13202 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13203 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13204 break 2
13205 fi
13206 done
13207 done
13208 IFS=$as_save_IFS
13209
13210 ;;
13211 esac
13212 fi
13213 SETFILE=$ac_cv_path_SETFILE
13214 if test -n "$SETFILE"; then
13215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13216 $as_echo "$SETFILE" >&6; }
13217 else
13218 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13219 $as_echo "no" >&6; }
13220 fi
13221
13222
13223 if test "x$SETFILE" = x; then
13224 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13225 fi
13226 else
13227 # Otherwise we believe it is a complete path. Use it as it is.
13228 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13229 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13230 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13231 $as_echo_n "checking for SETFILE... " >&6; }
13232 if test ! -x "$tool_specified"; then
13233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13234 $as_echo "not found" >&6; }
13235 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13236 fi
13237 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13238 $as_echo "$tool_specified" >&6; }
13239 fi
13240 fi
13241 fi
13242
13243
13244
13245
13246 # Publish this variable in the help.
13247
13248
13249 if test "x$CPIO" = x; then
13250 # The variable is not set by user, try to locate tool using the code snippet
13251 for ac_prog in cpio bsdcpio
13252 do
13253 # Extract the first word of "$ac_prog", so it can be a program name with args.
13254 set dummy $ac_prog; ac_word=$2
13255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13256 $as_echo_n "checking for $ac_word... " >&6; }
13257 if ${ac_cv_path_CPIO+:} false; then :
13258 $as_echo_n "(cached) " >&6
13259 else
13260 case $CPIO in
13261 [\\/]* | ?:[\\/]*)
13262 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13263 ;;
13264 *)
13265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13266 for as_dir in $PATH
13267 do
13268 IFS=$as_save_IFS
13269 test -z "$as_dir" && as_dir=.
13270 for ac_exec_ext in '' $ac_executable_extensions; do
13271 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13272 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13273 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13274 break 2
13275 fi
13276 done
13277 done
13278 IFS=$as_save_IFS
13279
13280 ;;
13281 esac
13282 fi
13283 CPIO=$ac_cv_path_CPIO
13284 if test -n "$CPIO"; then
13285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13286 $as_echo "$CPIO" >&6; }
13287 else
13288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13289 $as_echo "no" >&6; }
13290 fi
13291
13292
13293 test -n "$CPIO" && break
13294 done
13295
13296 else
13297 # The variable is set, but is it from the command line or the environment?
13298
13299 # Try to remove the string !CPIO! from our list.
13300 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13301 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13302 # If it failed, the variable was not from the command line. Ignore it,
13303 # but warn the user (except for BASH, which is always set by the calling BASH).
13304 if test "xCPIO" != xBASH; then
13305 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13306 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13307 fi
13308 # Try to locate tool using the code snippet
13309 for ac_prog in cpio bsdcpio
13310 do
13311 # Extract the first word of "$ac_prog", so it can be a program name with args.
13312 set dummy $ac_prog; ac_word=$2
13313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13314 $as_echo_n "checking for $ac_word... " >&6; }
13315 if ${ac_cv_path_CPIO+:} false; then :
13316 $as_echo_n "(cached) " >&6
13317 else
13318 case $CPIO in
13319 [\\/]* | ?:[\\/]*)
13320 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13321 ;;
13322 *)
13323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13324 for as_dir in $PATH
13325 do
13326 IFS=$as_save_IFS
13327 test -z "$as_dir" && as_dir=.
13328 for ac_exec_ext in '' $ac_executable_extensions; do
13329 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13330 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13331 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13332 break 2
13333 fi
13334 done
13335 done
13336 IFS=$as_save_IFS
13337
13338 ;;
13339 esac
13340 fi
13341 CPIO=$ac_cv_path_CPIO
13342 if test -n "$CPIO"; then
13343 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13344 $as_echo "$CPIO" >&6; }
13345 else
13346 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13347 $as_echo "no" >&6; }
13348 fi
13349
13350
13351 test -n "$CPIO" && break
13352 done
13353
13354 else
13355 # If it succeeded, then it was overridden by the user. We will use it
13356 # for the tool.
13357
13358 # First remove it from the list of overridden variables, so we can test
13359 # for unknown variables in the end.
13360 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13361
13362 # Check if the provided tool contains a complete path.
13363 tool_specified="$CPIO"
13364 tool_basename="${tool_specified##*/}"
13365 if test "x$tool_basename" = "x$tool_specified"; then
13366 # A command without a complete path is provided, search $PATH.
13367 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13368 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13369 # Extract the first word of "$tool_basename", so it can be a program name with args.
13370 set dummy $tool_basename; ac_word=$2
13371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13372 $as_echo_n "checking for $ac_word... " >&6; }
13373 if ${ac_cv_path_CPIO+:} false; then :
13374 $as_echo_n "(cached) " >&6
13375 else
13376 case $CPIO in
13377 [\\/]* | ?:[\\/]*)
13378 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13379 ;;
13380 *)
13381 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13382 for as_dir in $PATH
13383 do
13384 IFS=$as_save_IFS
13385 test -z "$as_dir" && as_dir=.
13386 for ac_exec_ext in '' $ac_executable_extensions; do
13387 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13388 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13389 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13390 break 2
13391 fi
13392 done
13393 done
13394 IFS=$as_save_IFS
13395
13396 ;;
13397 esac
13398 fi
13399 CPIO=$ac_cv_path_CPIO
13400 if test -n "$CPIO"; then
13401 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13402 $as_echo "$CPIO" >&6; }
13403 else
13404 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13405 $as_echo "no" >&6; }
13406 fi
13407
13408
13409 if test "x$CPIO" = x; then
13410 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13411 fi
13412 else
13413 # Otherwise we believe it is a complete path. Use it as it is.
13414 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13415 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13416 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13417 $as_echo_n "checking for CPIO... " >&6; }
13418 if test ! -x "$tool_specified"; then
13419 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13420 $as_echo "not found" >&6; }
13421 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13422 fi
13423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13424 $as_echo "$tool_specified" >&6; }
13425 fi
13426 fi
13427 fi
13428
13429
13430
13431
13432 # Now we can determine OpenJDK build and target platforms. This is required to
13433 # have early on.
13434 # Make sure we can run config.sub.
13435 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13436 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13437
13438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13439 $as_echo_n "checking build system type... " >&6; }
13440 if ${ac_cv_build+:} false; then :
13441 $as_echo_n "(cached) " >&6
13442 else
13443 ac_build_alias=$build_alias
13444 test "x$ac_build_alias" = x &&
13445 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13446 test "x$ac_build_alias" = x &&
13447 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13448 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13449 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13450
13451 fi
13452 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13453 $as_echo "$ac_cv_build" >&6; }
13454 case $ac_cv_build in
13455 *-*-*) ;;
13456 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13457 esac
13458 build=$ac_cv_build
13459 ac_save_IFS=$IFS; IFS='-'
13460 set x $ac_cv_build
13461 shift
13462 build_cpu=$1
13463 build_vendor=$2
13464 shift; shift
13465 # Remember, the first character of IFS is used to create $*,
13466 # except with old shells:
13467 build_os=$*
13468 IFS=$ac_save_IFS
13469 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13470
13471
13472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13473 $as_echo_n "checking host system type... " >&6; }
13474 if ${ac_cv_host+:} false; then :
13475 $as_echo_n "(cached) " >&6
13476 else
13477 if test "x$host_alias" = x; then
13478 ac_cv_host=$ac_cv_build
13479 else
13480 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13481 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13482 fi
13483
13484 fi
13485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13486 $as_echo "$ac_cv_host" >&6; }
13487 case $ac_cv_host in
13488 *-*-*) ;;
13489 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13490 esac
13491 host=$ac_cv_host
13492 ac_save_IFS=$IFS; IFS='-'
13493 set x $ac_cv_host
13494 shift
13495 host_cpu=$1
13496 host_vendor=$2
13497 shift; shift
13498 # Remember, the first character of IFS is used to create $*,
13499 # except with old shells:
13500 host_os=$*
13501 IFS=$ac_save_IFS
13502 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13503
13504
13505 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13506 $as_echo_n "checking target system type... " >&6; }
13507 if ${ac_cv_target+:} false; then :
13508 $as_echo_n "(cached) " >&6
13509 else
13510 if test "x$target_alias" = x; then
13511 ac_cv_target=$ac_cv_host
13512 else
13513 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13514 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13515 fi
13516
13517 fi
13518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13519 $as_echo "$ac_cv_target" >&6; }
13520 case $ac_cv_target in
13521 *-*-*) ;;
13522 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13523 esac
13524 target=$ac_cv_target
13525 ac_save_IFS=$IFS; IFS='-'
13526 set x $ac_cv_target
13527 shift
13528 target_cpu=$1
13529 target_vendor=$2
13530 shift; shift
13531 # Remember, the first character of IFS is used to create $*,
13532 # except with old shells:
13533 target_os=$*
13534 IFS=$ac_save_IFS
13535 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13536
13537
13538 # The aliases save the names the user supplied, while $host etc.
13539 # will get canonicalized.
13540 test -n "$target_alias" &&
13541 test "$program_prefix$program_suffix$program_transform_name" = \
13542 NONENONEs,x,x, &&
13543 program_prefix=${target_alias}-
13544
13545 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13546 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
13547 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13548 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13549 # to use the configure naming style.
13550
13551
13552
13553
13554
13555 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13556 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13557 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13558 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13559 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13560 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13561
13562
13563
13564 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13565
13566 case "$build_os" in
13567 *linux*)
13568 VAR_OS=linux
13569 VAR_OS_TYPE=unix
13570 ;;
13571 *solaris*)
13572 VAR_OS=solaris
13573 VAR_OS_TYPE=unix
13574 ;;
13575 *darwin*)
13576 VAR_OS=macosx
13577 VAR_OS_TYPE=unix
13578 ;;
13579 *bsd*)
13580 VAR_OS=bsd
13581 VAR_OS_TYPE=unix
13582 ;;
13583 *cygwin*)
13584 VAR_OS=windows
13585 VAR_OS_ENV=windows.cygwin
13586 ;;
13587 *mingw*)
13588 VAR_OS=windows
13589 VAR_OS_ENV=windows.msys
13590 ;;
13591 *aix*)
13592 VAR_OS=aix
13593 VAR_OS_TYPE=unix
13594 ;;
13595 *)
13596 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13597 ;;
13598 esac
13599
13600
13601 # First argument is the cpu name from the trip/quad
13602 case "$build_cpu" in
13603 x86_64)
13604 VAR_CPU=x86_64
13605 VAR_CPU_ARCH=x86
13606 VAR_CPU_BITS=64
13607 VAR_CPU_ENDIAN=little
13608 ;;
13609 i?86)
13610 VAR_CPU=x86
13611 VAR_CPU_ARCH=x86
13612 VAR_CPU_BITS=32
13613 VAR_CPU_ENDIAN=little
13614 ;;
13615 arm*)
13616 VAR_CPU=arm
13617 VAR_CPU_ARCH=arm
13618 VAR_CPU_BITS=32
13619 VAR_CPU_ENDIAN=little
13620 ;;
13621 aarch64)
13622 VAR_CPU=aarch64
13623 VAR_CPU_ARCH=aarch64
13624 VAR_CPU_BITS=64
13625 VAR_CPU_ENDIAN=little
13626 ;;
13627 powerpc)
13628 VAR_CPU=ppc
13629 VAR_CPU_ARCH=ppc
13630 VAR_CPU_BITS=32
13631 VAR_CPU_ENDIAN=big
13632 ;;
13633 powerpc64)
13634 VAR_CPU=ppc64
13635 VAR_CPU_ARCH=ppc
13636 VAR_CPU_BITS=64
13637 VAR_CPU_ENDIAN=big
13638 ;;
13639 powerpc64le)
13640 VAR_CPU=ppc64
13641 VAR_CPU_ARCH=ppc
13642 VAR_CPU_BITS=64
13643 VAR_CPU_ENDIAN=little
13644 ;;
13645 s390)
13646 VAR_CPU=s390
13647 VAR_CPU_ARCH=s390
13648 VAR_CPU_BITS=32
13649 VAR_CPU_ENDIAN=big
13650 ;;
13651 s390x)
13652 VAR_CPU=s390x
13653 VAR_CPU_ARCH=s390
13654 VAR_CPU_BITS=64
13655 VAR_CPU_ENDIAN=big
13656 ;;
13657 sparc)
13658 VAR_CPU=sparc
13659 VAR_CPU_ARCH=sparc
13660 VAR_CPU_BITS=32
13661 VAR_CPU_ENDIAN=big
13662 ;;
13663 sparcv9|sparc64)
13664 VAR_CPU=sparcv9
13665 VAR_CPU_ARCH=sparc
13666 VAR_CPU_BITS=64
13667 VAR_CPU_ENDIAN=big
13668 ;;
13669 *)
13670 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13671 ;;
13672 esac
13673
13674 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13675 OPENJDK_BUILD_OS="$VAR_OS"
13676 if test "x$VAR_OS_TYPE" != x; then
13677 OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13678 else
13679 OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13680 fi
13681 if test "x$VAR_OS_ENV" != x; then
13682 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13683 else
13684 OPENJDK_BUILD_OS_ENV="$VAR_OS"
13685 fi
13686 OPENJDK_BUILD_CPU="$VAR_CPU"
13687 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13688 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13689 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13690
13691
13692
13693
13694
13695
13696
13697
13698 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13699 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13701 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13702
13703 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13704
13705 case "$host_os" in
13706 *linux*)
13707 VAR_OS=linux
13708 VAR_OS_TYPE=unix
13709 ;;
13710 *solaris*)
13711 VAR_OS=solaris
13712 VAR_OS_TYPE=unix
13713 ;;
13714 *darwin*)
13715 VAR_OS=macosx
13716 VAR_OS_TYPE=unix
13717 ;;
13718 *bsd*)
13719 VAR_OS=bsd
13720 VAR_OS_TYPE=unix
13721 ;;
13722 *cygwin*)
13723 VAR_OS=windows
13724 VAR_OS_ENV=windows.cygwin
13725 ;;
13726 *mingw*)
13727 VAR_OS=windows
13728 VAR_OS_ENV=windows.msys
13729 ;;
13730 *aix*)
13731 VAR_OS=aix
13732 VAR_OS_TYPE=unix
13733 ;;
13734 *)
13735 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13736 ;;
13737 esac
13738
13739
13740 # First argument is the cpu name from the trip/quad
13741 case "$host_cpu" in
13742 x86_64)
13743 VAR_CPU=x86_64
13744 VAR_CPU_ARCH=x86
13745 VAR_CPU_BITS=64
13746 VAR_CPU_ENDIAN=little
13747 ;;
13748 i?86)
13749 VAR_CPU=x86
13750 VAR_CPU_ARCH=x86
13751 VAR_CPU_BITS=32
13752 VAR_CPU_ENDIAN=little
13753 ;;
13754 arm*)
13755 VAR_CPU=arm
13756 VAR_CPU_ARCH=arm
13757 VAR_CPU_BITS=32
13758 VAR_CPU_ENDIAN=little
13759 ;;
13760 aarch64)
13761 VAR_CPU=aarch64
13762 VAR_CPU_ARCH=aarch64
13763 VAR_CPU_BITS=64
13764 VAR_CPU_ENDIAN=little
13765 ;;
13766 powerpc)
13767 VAR_CPU=ppc
13768 VAR_CPU_ARCH=ppc
13769 VAR_CPU_BITS=32
13770 VAR_CPU_ENDIAN=big
13771 ;;
13772 powerpc64)
13773 VAR_CPU=ppc64
13774 VAR_CPU_ARCH=ppc
13775 VAR_CPU_BITS=64
13776 VAR_CPU_ENDIAN=big
13777 ;;
13778 powerpc64le)
13779 VAR_CPU=ppc64
13780 VAR_CPU_ARCH=ppc
13781 VAR_CPU_BITS=64
13782 VAR_CPU_ENDIAN=little
13783 ;;
13784 s390)
13785 VAR_CPU=s390
13786 VAR_CPU_ARCH=s390
13787 VAR_CPU_BITS=32
13788 VAR_CPU_ENDIAN=big
13789 ;;
13790 s390x)
13791 VAR_CPU=s390x
13792 VAR_CPU_ARCH=s390
13793 VAR_CPU_BITS=64
13794 VAR_CPU_ENDIAN=big
13795 ;;
13796 sparc)
13797 VAR_CPU=sparc
13798 VAR_CPU_ARCH=sparc
13799 VAR_CPU_BITS=32
13800 VAR_CPU_ENDIAN=big
13801 ;;
13802 sparcv9|sparc64)
13803 VAR_CPU=sparcv9
13804 VAR_CPU_ARCH=sparc
13805 VAR_CPU_BITS=64
13806 VAR_CPU_ENDIAN=big
13807 ;;
13808 *)
13809 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13810 ;;
13811 esac
13812
13813 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13814 OPENJDK_TARGET_OS="$VAR_OS"
13815 if test "x$VAR_OS_TYPE" != x; then
13816 OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13817 else
13818 OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13819 fi
13820 if test "x$VAR_OS_ENV" != x; then
13821 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13822 else
13823 OPENJDK_TARGET_OS_ENV="$VAR_OS"
13824 fi
13825 OPENJDK_TARGET_CPU="$VAR_CPU"
13826 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13827 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13828 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13829
13830
13831
13832
13833
13834
13835
13836
13837 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13838 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13840 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13841
13842
13843
13844 # Check whether --with-target-bits was given.
13845 if test "${with_target_bits+set}" = set; then :
13846 withval=$with_target_bits;
13847 fi
13848
13849
13850 # We have three types of compiles:
13851 # native == normal compilation, target system == build system
13852 # cross == traditional cross compilation, target system != build system; special toolchain needed
13853 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13854 #
13855 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13856 # We're doing a proper cross-compilation
13857 COMPILE_TYPE="cross"
13858 else
13859 COMPILE_TYPE="native"
13860 fi
13861
13862 if test "x$with_target_bits" != x; then
13863 if test "x$COMPILE_TYPE" = "xcross"; then
13864 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13865 fi
13866
13867 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13868 # A reduced build is requested
13869 COMPILE_TYPE="reduced"
13870 OPENJDK_TARGET_CPU_BITS=32
13871 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13872 OPENJDK_TARGET_CPU=x86
13873 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13874 OPENJDK_TARGET_CPU=sparc
13875 else
13876 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13877 fi
13878 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13879 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
13880 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13881 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13882 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13883 else
13884 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13885 fi
13886 fi
13887
13888
13889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13890 $as_echo_n "checking compilation type... " >&6; }
13891 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13892 $as_echo "$COMPILE_TYPE" >&6; }
13893
13894
13895 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13896 REQUIRED_OS_NAME=SunOS
13897 REQUIRED_OS_VERSION=5.10
13898 fi
13899 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13900 REQUIRED_OS_NAME=Linux
13901 REQUIRED_OS_VERSION=2.6
13902 fi
13903 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13904 REQUIRED_OS_NAME=Windows
13905 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13906 REQUIRED_OS_VERSION=5.2
13907 else
13908 REQUIRED_OS_VERSION=5.1
13909 fi
13910 fi
13911 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13912 REQUIRED_OS_NAME=Darwin
13913 REQUIRED_OS_VERSION=11.2
13914 fi
13915
13916
13917
13918
13919
13920 # Also store the legacy naming of the cpu.
13921 # Ie i586 and amd64 instead of x86 and x86_64
13922 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13923 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13924 OPENJDK_TARGET_CPU_LEGACY="i586"
13925 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13926 # On all platforms except MacOSX replace x86_64 with amd64.
13927 OPENJDK_TARGET_CPU_LEGACY="amd64"
13928 fi
13929
13930
13931 # And the second legacy naming of the cpu.
13932 # Ie i386 and amd64 instead of x86 and x86_64.
13933 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13934 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13935 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13936 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13937 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13938 fi
13939
13940
13941 # This is the name of the cpu (but using i386 and amd64 instead of
13942 # x86 and x86_64, respectively), preceeded by a /, to be used when
13943 # locating libraries. On macosx, it's empty, though.
13944 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13945 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13946 OPENJDK_TARGET_CPU_LIBDIR=""
13947 fi
13948
13949
13950 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13951 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13952 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13953 OPENJDK_TARGET_CPU_ISADIR=""
13954 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13955 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13956 OPENJDK_TARGET_CPU_ISADIR="/amd64"
13957 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13958 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13959 fi
13960 fi
13961
13962
13963 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13964 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13965 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13966 # On linux only, we replace x86 with i386.
13967 OPENJDK_TARGET_CPU_OSARCH="i386"
13968 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13969 # On all platforms except macosx, we replace x86_64 with amd64.
13970 OPENJDK_TARGET_CPU_OSARCH="amd64"
13971 fi
13972
13973
13974 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13975 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13976 OPENJDK_TARGET_CPU_JLI="i386"
13977 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13978 # On all platforms except macosx, we replace x86_64 with amd64.
13979 OPENJDK_TARGET_CPU_JLI="amd64"
13980 fi
13981 # Now setup the -D flags for building libjli.
13982 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13983 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13984 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13985 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13986 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13987 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13988 fi
13989 fi
13990
13991
13992 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13993 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13994 else
13995 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
13996 fi
13997
13998
13999 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14000 A_LP64="LP64:="
14001 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
14002 # unpack200.exe
14003 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
14004 ADD_LP64="-D_LP64=1"
14005 fi
14006 fi
14007 LP64=$A_LP64
14008
14009
14010 if test "x$COMPILE_TYPE" = "xcross"; then
14011 # FIXME: ... or should this include reduced builds..?
14012 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
14013 else
14014 DEFINE_CROSS_COMPILE_ARCH=""
14015 fi
14016
14017
14018 # ZERO_ARCHDEF is used to enable architecture-specific code
14019 case "${OPENJDK_TARGET_CPU}" in
14020 ppc) ZERO_ARCHDEF=PPC32 ;;
14021 ppc64) ZERO_ARCHDEF=PPC64 ;;
14022 s390*) ZERO_ARCHDEF=S390 ;;
14023 sparc*) ZERO_ARCHDEF=SPARC ;;
14024 x86_64*) ZERO_ARCHDEF=AMD64 ;;
14025 x86) ZERO_ARCHDEF=IA32 ;;
14026 *) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14027 esac
14028
14029
14030
14031
14032 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14033
14034 # Save the current directory this script was started from
14035 CURDIR="$PWD"
14036
14037 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14038 PATH_SEP=";"
14039
14040 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14041 if test $SRC_ROOT_LENGTH -gt 100; then
14042 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14043 fi
14044
14045 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14047 $as_echo_n "checking cygwin release... " >&6; }
14048 CYGWIN_VERSION=`$UNAME -r`
14049 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14050 $as_echo "$CYGWIN_VERSION" >&6; }
14051 WINDOWS_ENV_VENDOR='cygwin'
14052 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14053
14054 CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
14055 if test "x$CYGWIN_VERSION_OLD" != x; then
14056 { $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
14057 $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;}
14058 as_fn_error $? "Cannot continue" "$LINENO" 5
14059 fi
14060 if test "x$CYGPATH" = x; then
14061 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14062 fi
14063 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14064 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14065 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14066 cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
14067 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14068 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14070 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14071 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14072 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14073 if test "x$test_cygdrive_prefix" = x; then
14074 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14075 fi
14076 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14077 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14078 $as_echo_n "checking msys release... " >&6; }
14079 MSYS_VERSION=`$UNAME -r`
14080 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14081 $as_echo "$MSYS_VERSION" >&6; }
14082
14083 WINDOWS_ENV_VENDOR='msys'
14084 WINDOWS_ENV_VERSION="$MSYS_VERSION"
14085
14086 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14087 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14088 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14089 MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14090
14091 windows_path="$MSYS_ROOT_PATH"
14092 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14093 unix_path=`$CYGPATH -u "$windows_path"`
14094 MSYS_ROOT_PATH="$unix_path"
14095 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14096 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14097 MSYS_ROOT_PATH="$unix_path"
14098 fi
14099
14100 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14101 $as_echo "$MSYS_ROOT_PATH" >&6; }
14102 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14103 else
14104 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14105 fi
14106
14107 # Test if windows or unix (cygwin/msys) find is first in path.
14108 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14109 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14110 FIND_BINARY_OUTPUT=`find --version 2>&1`
14111 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14112 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14113 $as_echo "unix style" >&6; }
14114 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14116 $as_echo "Windows" >&6; }
14117 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14118 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14119 { $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
14120 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14121 as_fn_error $? "Cannot continue" "$LINENO" 5
14122 else
14123 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14124 $as_echo "unknown" >&6; }
14125 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14126 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14127 fi
14128
14129 else
14130 PATH_SEP=":"
14131 fi
14132
14133
14134 # We get the top-level directory from the supporting wrappers.
14135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14136 $as_echo_n "checking for top-level directory... " >&6; }
14137 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14138 $as_echo "$TOPDIR" >&6; }
14139
14140
14141 # Save the original version of TOPDIR for string comparisons
14142 ORIGINAL_TOPDIR="$TOPDIR"
14143
14144
14145 # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14146
14147 # Only process if variable expands to non-empty
14148
14149 if test "x$CURDIR" != x; then
14150 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14151
14152 # Input might be given as Windows format, start by converting to
14153 # unix format.
14154 path="$CURDIR"
14155 new_path=`$CYGPATH -u "$path"`
14156
14157 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14158 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14159 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14160 # "foo.exe" is OK but "foo" is an error.
14161 #
14162 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14163 # It is also a way to make sure we got the proper file name for the real test later on.
14164 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14165 if test "x$test_shortpath" = x; then
14166 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14167 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14168 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14169 fi
14170
14171 # Call helper function which possibly converts this using DOS-style short mode.
14172 # If so, the updated path is stored in $new_path.
14173
14174 input_path="$new_path"
14175 # Check if we need to convert this using DOS-style short mode. If the path
14176 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14177 # take no chances and rewrite it.
14178 # Note: m4 eats our [], so we need to use [ and ] instead.
14179 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14180 if test "x$has_forbidden_chars" != x; then
14181 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14182 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14183 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14184 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14185 # Going to short mode and back again did indeed matter. Since short mode is
14186 # case insensitive, let's make it lowercase to improve readability.
14187 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14188 # Now convert it back to Unix-style (cygpath)
14189 input_path=`$CYGPATH -u "$shortmode_path"`
14190 new_path="$input_path"
14191 fi
14192 fi
14193
14194 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14195 if test "x$test_cygdrive_prefix" = x; then
14196 # As a simple fix, exclude /usr/bin since it's not a real path.
14197 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14198 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14199 # a path prefixed by /cygdrive for fixpath to work.
14200 new_path="$CYGWIN_ROOT_PATH$input_path"
14201 fi
14202 fi
14203
14204
14205 if test "x$path" != "x$new_path"; then
14206 CURDIR="$new_path"
14207 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14208 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14209 fi
14210
14211 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14212
14213 path="$CURDIR"
14214 has_colon=`$ECHO $path | $GREP ^.:`
14215 new_path="$path"
14216 if test "x$has_colon" = x; then
14217 # Not in mixed or Windows style, start by that.
14218 new_path=`cmd //c echo $path`
14219 fi
14220
14221
14222 input_path="$new_path"
14223 # Check if we need to convert this using DOS-style short mode. If the path
14224 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14225 # take no chances and rewrite it.
14226 # Note: m4 eats our [], so we need to use [ and ] instead.
14227 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14228 if test "x$has_forbidden_chars" != x; then
14229 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14230 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14231 fi
14232
14233
14234 windows_path="$new_path"
14235 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14236 unix_path=`$CYGPATH -u "$windows_path"`
14237 new_path="$unix_path"
14238 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14239 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14240 new_path="$unix_path"
14241 fi
14242
14243 if test "x$path" != "x$new_path"; then
14244 CURDIR="$new_path"
14245 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14246 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14247 fi
14248
14249 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14250 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14251
14252 else
14253 # We're on a unix platform. Hooray! :)
14254 path="$CURDIR"
14255 has_space=`$ECHO "$path" | $GREP " "`
14256 if test "x$has_space" != x; then
14257 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14258 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14259 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14260 fi
14261
14262 # Use eval to expand a potential ~
14263 eval path="$path"
14264 if test ! -f "$path" && test ! -d "$path"; then
14265 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14266 fi
14267
14268 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14269 fi
14270 fi
14271
14272
14273 # Only process if variable expands to non-empty
14274
14275 if test "x$TOPDIR" != x; then
14276 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14277
14278 # Input might be given as Windows format, start by converting to
14279 # unix format.
14280 path="$TOPDIR"
14281 new_path=`$CYGPATH -u "$path"`
14282
14283 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14284 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14285 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14286 # "foo.exe" is OK but "foo" is an error.
14287 #
14288 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14289 # It is also a way to make sure we got the proper file name for the real test later on.
14290 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14291 if test "x$test_shortpath" = x; then
14292 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14293 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14294 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14295 fi
14296
14297 # Call helper function which possibly converts this using DOS-style short mode.
14298 # If so, the updated path is stored in $new_path.
14299
14300 input_path="$new_path"
14301 # Check if we need to convert this using DOS-style short mode. If the path
14302 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14303 # take no chances and rewrite it.
14304 # Note: m4 eats our [], so we need to use [ and ] instead.
14305 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14306 if test "x$has_forbidden_chars" != x; then
14307 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14308 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14309 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14310 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14311 # Going to short mode and back again did indeed matter. Since short mode is
14312 # case insensitive, let's make it lowercase to improve readability.
14313 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14314 # Now convert it back to Unix-style (cygpath)
14315 input_path=`$CYGPATH -u "$shortmode_path"`
14316 new_path="$input_path"
14317 fi
14318 fi
14319
14320 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14321 if test "x$test_cygdrive_prefix" = x; then
14322 # As a simple fix, exclude /usr/bin since it's not a real path.
14323 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14324 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14325 # a path prefixed by /cygdrive for fixpath to work.
14326 new_path="$CYGWIN_ROOT_PATH$input_path"
14327 fi
14328 fi
14329
14330
14331 if test "x$path" != "x$new_path"; then
14332 TOPDIR="$new_path"
14333 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14334 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14335 fi
14336
14337 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14338
14339 path="$TOPDIR"
14340 has_colon=`$ECHO $path | $GREP ^.:`
14341 new_path="$path"
14342 if test "x$has_colon" = x; then
14343 # Not in mixed or Windows style, start by that.
14344 new_path=`cmd //c echo $path`
14345 fi
14346
14347
14348 input_path="$new_path"
14349 # Check if we need to convert this using DOS-style short mode. If the path
14350 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14351 # take no chances and rewrite it.
14352 # Note: m4 eats our [], so we need to use [ and ] instead.
14353 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14354 if test "x$has_forbidden_chars" != x; then
14355 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14356 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14357 fi
14358
14359
14360 windows_path="$new_path"
14361 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14362 unix_path=`$CYGPATH -u "$windows_path"`
14363 new_path="$unix_path"
14364 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14365 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14366 new_path="$unix_path"
14367 fi
14368
14369 if test "x$path" != "x$new_path"; then
14370 TOPDIR="$new_path"
14371 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14372 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14373 fi
14374
14375 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14376 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14377
14378 else
14379 # We're on a unix platform. Hooray! :)
14380 path="$TOPDIR"
14381 has_space=`$ECHO "$path" | $GREP " "`
14382 if test "x$has_space" != x; then
14383 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14384 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14385 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14386 fi
14387
14388 # Use eval to expand a potential ~
14389 eval path="$path"
14390 if test ! -f "$path" && test ! -d "$path"; then
14391 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14392 fi
14393
14394 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14395 fi
14396 fi
14397
14398 # SRC_ROOT is a traditional alias for TOPDIR.
14399 SRC_ROOT=$TOPDIR
14400
14401 # Calculate a canonical version of TOPDIR for string comparisons
14402 CANONICAL_TOPDIR=$TOPDIR
14403
14404 if test "x$OPENJDK_BUILD_OS" != xwindows; then
14405 # Follow a chain of symbolic links. Use readlink
14406 # where it exists, else fall back to horribly
14407 # complicated shell code.
14408 if test "x$READLINK_TESTED" != yes; then
14409 # On MacOSX there is a readlink tool with a different
14410 # purpose than the GNU readlink tool. Check the found readlink.
14411 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
14412 if test "x$ISGNU" = x; then
14413 # A readlink that we do not know how to use.
14414 # Are there other non-GNU readlinks out there?
14415 READLINK_TESTED=yes
14416 READLINK=
14417 fi
14418 fi
14419
14420 if test "x$READLINK" != x; then
14421 CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
14422 else
14423 # Save the current directory for restoring afterwards
14424 STARTDIR=$PWD
14425 COUNTER=0
14426 sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
14427 sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
14428 cd $sym_link_dir
14429 # Use -P flag to resolve symlinks in directories.
14430 cd `$THEPWDCMD -P`
14431 sym_link_dir=`$THEPWDCMD -P`
14432 # Resolve file symlinks
14433 while test $COUNTER -lt 20; do
14434 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
14435 if test "x$ISLINK" == x; then
14436 # This is not a symbolic link! We are done!
14437 break
14438 fi
14439 # Again resolve directory symlinks since the target of the just found
14440 # link could be in a different directory
14441 cd `$DIRNAME $ISLINK`
14442 sym_link_dir=`$THEPWDCMD -P`
14443 sym_link_file=`$BASENAME $ISLINK`
14444 let COUNTER=COUNTER+1
14445 done
14446 cd $STARTDIR
14447 CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
14448 fi
14449 fi
14450
14451
14452
14453 # Locate the directory of this script.
14454 AUTOCONF_DIR=$TOPDIR/common/autoconf
14455
14456
14457 # Check if it's a pure open build or if custom sources are to be used.
14458
14459 # Check whether --enable-openjdk-only was given.
14460 if test "${enable_openjdk_only+set}" = set; then :
14461 enableval=$enable_openjdk_only;
14462 else
14463 enable_openjdk_only="no"
14464 fi
14465
14466
14467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14468 $as_echo_n "checking for presence of closed sources... " >&6; }
14469 if test -d "$SRC_ROOT/jdk/src/closed"; then
14470 CLOSED_SOURCE_PRESENT=yes
14471 else
14472 CLOSED_SOURCE_PRESENT=no
14473 fi
14474 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14475 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14476
14477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14478 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14479 SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14481 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14482
14483 if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14484 OPENJDK=true
14485 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14486 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14487 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14488 fi
14489 else
14490 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14491 OPENJDK=true
14492 else
14493 OPENJDK=false
14494 fi
14495 fi
14496
14497 if test "x$OPENJDK" = "xtrue"; then
14498 SET_OPENJDK="OPENJDK=true"
14499 fi
14500
14501
14502
14503 # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14504 # the IncludeCustomExtension macro.
14505
14506
14507 # Check whether --with-custom-make-dir was given.
14508 if test "${with_custom_make_dir+set}" = set; then :
14509 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
14510 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14511 fi
14512
14513
14514
14515
14516 # These are needed to be able to create a configuration name (and thus the output directory)
14517
14518 ###############################################################################
14519 #
14520 # Check which variant of the JDK that we want to build.
14521 # Currently we have:
14522 # normal: standard edition
14523 # but the custom make system may add other variants
14524 #
14525 # Effectively the JDK variant gives a name to a specific set of
14526 # modules to compile into the JDK. In the future, these modules
14527 # might even be Jigsaw modules.
14528 #
14529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14530 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14531
14532 # Check whether --with-jdk-variant was given.
14533 if test "${with_jdk_variant+set}" = set; then :
14534 withval=$with_jdk_variant;
14535 fi
14536
14537
14538 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14539 JDK_VARIANT="normal"
14540 else
14541 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14542 fi
14543
14544
14545
14546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14547 $as_echo "$JDK_VARIANT" >&6; }
14548
14549
14550 ###############################################################################
14551 #
14552 # Check which interpreter of the JVM we want to build.
14553 # Currently we have:
14554 # template: Template interpreter (the default)
14555 # cpp : C++ interpreter
14556 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14557 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14558
14559 # Check whether --with-jvm-interpreter was given.
14560 if test "${with_jvm_interpreter+set}" = set; then :
14561 withval=$with_jvm_interpreter;
14562 fi
14563
14564
14565 if test "x$with_jvm_interpreter" = x; then
14566 with_jvm_interpreter="template"
14567 fi
14568
14569 JVM_INTERPRETER="$with_jvm_interpreter"
14570
14571 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14572 as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14573 fi
14574
14575
14576
14577 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14578 $as_echo "$with_jvm_interpreter" >&6; }
14579
14580
14581
14582 ###############################################################################
14583 #
14584 # Check which variants of the JVM that we want to build.
14585 # Currently we have:
14586 # server: normal interpreter and a tiered C1/C2 compiler
14587 # client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14588 # minimal1: reduced form of client with optional VM services and features stripped out
14589 # kernel: kernel footprint JVM that passes the TCK without major performance problems,
14590 # ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14591 # zero: no machine code interpreter, no compiler
14592 # zeroshark: zero interpreter and shark/llvm compiler backend
14593 # core: interpreter only, no compiler (only works on some platforms)
14594 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14595 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14596
14597 # Check whether --with-jvm-variants was given.
14598 if test "${with_jvm_variants+set}" = set; then :
14599 withval=$with_jvm_variants;
14600 fi
14601
14602
14603 if test "x$with_jvm_variants" = x; then
14604 with_jvm_variants="server"
14605 fi
14606
14607 JVM_VARIANTS=",$with_jvm_variants,"
14608 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,//'`
14609
14610 if test "x$TEST_VARIANTS" != "x,"; then
14611 as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14612 fi
14613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14614 $as_echo "$with_jvm_variants" >&6; }
14615
14616 JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14617 JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14618 JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14619 JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14620 JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14621 JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14622 JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14623
14624 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14625 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14626 as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14627 fi
14628 fi
14629 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14630 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14631 as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14632 fi
14633 fi
14634 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14635 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14636 as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14637 fi
14638 fi
14639
14640 # Replace the commas with AND for use in the build directory name.
14641 ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14642 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/'`
14643 if test "x$COUNT_VARIANTS" != "x,1"; then
14644 BUILDING_MULTIPLE_JVM_VARIANTS=yes
14645 else
14646 BUILDING_MULTIPLE_JVM_VARIANTS=no
14647 fi
14648
14649
14650
14651
14652
14653
14654
14655
14656
14657
14658 INCLUDE_SA=true
14659 if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14660 INCLUDE_SA=false
14661 fi
14662 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14663 INCLUDE_SA=false
14664 fi
14665 if test "x$OPENJDK_TARGET_OS" = xaix ; then
14666 INCLUDE_SA=false
14667 fi
14668 if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14669 INCLUDE_SA=false
14670 fi
14671
14672
14673 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14674 MACOSX_UNIVERSAL="true"
14675 fi
14676
14677
14678
14679
14680 ###############################################################################
14681 #
14682 # Set the debug level
14683 # release: no debug information, all optimizations, no asserts.
14684 # optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14685 # fastdebug: debug information (-g), all optimizations, all asserts
14686 # slowdebug: debug information (-g), no optimizations, all asserts
14687 #
14688 DEBUG_LEVEL="release"
14689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14690 $as_echo_n "checking which debug level to use... " >&6; }
14691 # Check whether --enable-debug was given.
14692 if test "${enable_debug+set}" = set; then :
14693 enableval=$enable_debug;
14694 ENABLE_DEBUG="${enableval}"
14695 DEBUG_LEVEL="fastdebug"
14696
14697 else
14698 ENABLE_DEBUG="no"
14699 fi
14700
14701
14702
14703 # Check whether --with-debug-level was given.
14704 if test "${with_debug_level+set}" = set; then :
14705 withval=$with_debug_level;
14706 DEBUG_LEVEL="${withval}"
14707 if test "x$ENABLE_DEBUG" = xyes; then
14708 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14709 fi
14710
14711 fi
14712
14713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14714 $as_echo "$DEBUG_LEVEL" >&6; }
14715
14716 if test "x$DEBUG_LEVEL" != xrelease && \
14717 test "x$DEBUG_LEVEL" != xoptimized && \
14718 test "x$DEBUG_LEVEL" != xfastdebug && \
14719 test "x$DEBUG_LEVEL" != xslowdebug; then
14720 as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14721 fi
14722
14723
14724 ###############################################################################
14725 #
14726 # Setup legacy vars/targets and new vars to deal with different debug levels.
14727 #
14728
14729 case $DEBUG_LEVEL in
14730 release )
14731 VARIANT="OPT"
14732 FASTDEBUG="false"
14733 DEBUG_CLASSFILES="false"
14734 BUILD_VARIANT_RELEASE=""
14735 HOTSPOT_DEBUG_LEVEL="product"
14736 HOTSPOT_EXPORT="product"
14737 ;;
14738 fastdebug )
14739 VARIANT="DBG"
14740 FASTDEBUG="true"
14741 DEBUG_CLASSFILES="true"
14742 BUILD_VARIANT_RELEASE="-fastdebug"
14743 HOTSPOT_DEBUG_LEVEL="fastdebug"
14744 HOTSPOT_EXPORT="fastdebug"
14745 ;;
14746 slowdebug )
14747 VARIANT="DBG"
14748 FASTDEBUG="false"
14749 DEBUG_CLASSFILES="true"
14750 BUILD_VARIANT_RELEASE="-debug"
14751 HOTSPOT_DEBUG_LEVEL="debug"
14752 HOTSPOT_EXPORT="debug"
14753 ;;
14754 optimized )
14755 VARIANT="OPT"
14756 FASTDEBUG="false"
14757 DEBUG_CLASSFILES="false"
14758 BUILD_VARIANT_RELEASE="-optimized"
14759 HOTSPOT_DEBUG_LEVEL="optimized"
14760 HOTSPOT_EXPORT="optimized"
14761 ;;
14762 esac
14763
14764 # The debug level 'optimized' is a little special because it is currently only
14765 # applicable to the HotSpot build where it means to build a completely
14766 # optimized version of the VM without any debugging code (like for the
14767 # 'release' debug level which is called 'product' in the HotSpot build) but
14768 # with the exception that it can contain additional code which is otherwise
14769 # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14770 # test new and/or experimental features which are not intended for customer
14771 # shipment. Because these new features need to be tested and benchmarked in
14772 # real world scenarios, we want to build the containing JDK at the 'release'
14773 # debug level.
14774 if test "x$DEBUG_LEVEL" = xoptimized; then
14775 DEBUG_LEVEL="release"
14776 fi
14777
14778 #####
14779 # Generate the legacy makefile targets for hotspot.
14780 # The hotspot api for selecting the build artifacts, really, needs to be improved.
14781 # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14782 # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14783 # But until then ...
14784 HOTSPOT_TARGET=""
14785
14786 if test "x$JVM_VARIANT_SERVER" = xtrue; then
14787 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14788 fi
14789
14790 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14791 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14792 fi
14793
14794 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14795 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14796 fi
14797
14798 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14799 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14800 fi
14801
14802 if test "x$JVM_VARIANT_ZERO" = xtrue; then
14803 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14804 fi
14805
14806 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14807 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14808 fi
14809
14810 if test "x$JVM_VARIANT_CORE" = xtrue; then
14811 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14812 fi
14813
14814 HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14815
14816 # On Macosx universal binaries are produced, but they only contain
14817 # 64 bit intel. This invalidates control of which jvms are built
14818 # from configure, but only server is valid anyway. Fix this
14819 # when hotspot makefiles are rewritten.
14820 if test "x$MACOSX_UNIVERSAL" = xtrue; then
14821 HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14822 fi
14823
14824 #####
14825
14826
14827
14828
14829
14830
14831
14832
14833 # With basic setup done, call the custom early hook.
14834
14835
14836 # Check if we have devkits, extra paths or sysroot set.
14837
14838
14839 # Check whether --with-devkit was given.
14840 if test "${with_devkit+set}" = set; then :
14841 withval=$with_devkit;
14842
14843 # Only process if variable expands to non-empty
14844
14845 if test "x$with_devkit" != x; then
14846 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14847
14848 # Input might be given as Windows format, start by converting to
14849 # unix format.
14850 path="$with_devkit"
14851 new_path=`$CYGPATH -u "$path"`
14852
14853 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14854 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14855 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14856 # "foo.exe" is OK but "foo" is an error.
14857 #
14858 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14859 # It is also a way to make sure we got the proper file name for the real test later on.
14860 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14861 if test "x$test_shortpath" = x; then
14862 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14863 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14864 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14865 fi
14866
14867 # Call helper function which possibly converts this using DOS-style short mode.
14868 # If so, the updated path is stored in $new_path.
14869
14870 input_path="$new_path"
14871 # Check if we need to convert this using DOS-style short mode. If the path
14872 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14873 # take no chances and rewrite it.
14874 # Note: m4 eats our [], so we need to use [ and ] instead.
14875 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14876 if test "x$has_forbidden_chars" != x; then
14877 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14878 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14879 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14880 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14881 # Going to short mode and back again did indeed matter. Since short mode is
14882 # case insensitive, let's make it lowercase to improve readability.
14883 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14884 # Now convert it back to Unix-style (cygpath)
14885 input_path=`$CYGPATH -u "$shortmode_path"`
14886 new_path="$input_path"
14887 fi
14888 fi
14889
14890 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14891 if test "x$test_cygdrive_prefix" = x; then
14892 # As a simple fix, exclude /usr/bin since it's not a real path.
14893 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14894 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14895 # a path prefixed by /cygdrive for fixpath to work.
14896 new_path="$CYGWIN_ROOT_PATH$input_path"
14897 fi
14898 fi
14899
14900
14901 if test "x$path" != "x$new_path"; then
14902 with_devkit="$new_path"
14903 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14904 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14905 fi
14906
14907 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14908
14909 path="$with_devkit"
14910 has_colon=`$ECHO $path | $GREP ^.:`
14911 new_path="$path"
14912 if test "x$has_colon" = x; then
14913 # Not in mixed or Windows style, start by that.
14914 new_path=`cmd //c echo $path`
14915 fi
14916
14917
14918 input_path="$new_path"
14919 # Check if we need to convert this using DOS-style short mode. If the path
14920 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14921 # take no chances and rewrite it.
14922 # Note: m4 eats our [], so we need to use [ and ] instead.
14923 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14924 if test "x$has_forbidden_chars" != x; then
14925 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14926 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14927 fi
14928
14929
14930 windows_path="$new_path"
14931 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14932 unix_path=`$CYGPATH -u "$windows_path"`
14933 new_path="$unix_path"
14934 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14935 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14936 new_path="$unix_path"
14937 fi
14938
14939 if test "x$path" != "x$new_path"; then
14940 with_devkit="$new_path"
14941 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14942 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14943 fi
14944
14945 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14946 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14947
14948 else
14949 # We're on a unix platform. Hooray! :)
14950 path="$with_devkit"
14951 has_space=`$ECHO "$path" | $GREP " "`
14952 if test "x$has_space" != x; then
14953 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14954 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14955 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14956 fi
14957
14958 # Use eval to expand a potential ~
14959 eval path="$path"
14960 if test ! -f "$path" && test ! -d "$path"; then
14961 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14962 fi
14963
14964 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14965 fi
14966 fi
14967
14968 DEVKIT_ROOT="$with_devkit"
14969 # Check for a meta data info file in the root of the devkit
14970 if test -f "$DEVKIT_ROOT/devkit.info"; then
14971 . $DEVKIT_ROOT/devkit.info
14972 # This potentially sets the following:
14973 # A descriptive name of the devkit
14974
14975 if test "x$DEVKIT_NAME" = x; then
14976 eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
14977 fi
14978
14979 # Corresponds to --with-extra-path
14980
14981 if test "x$DEVKIT_EXTRA_PATH" = x; then
14982 eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
14983 fi
14984
14985 # Corresponds to --with-toolchain-path
14986
14987 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14988 eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
14989 fi
14990
14991 # Corresponds to --with-sysroot
14992
14993 if test "x$DEVKIT_SYSROOT" = x; then
14994 eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
14995 fi
14996
14997
14998 # Identifies the Visual Studio version in the devkit
14999
15000 if test "x$DEVKIT_VS_VERSION" = x; then
15001 eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
15002 fi
15003
15004 # The Visual Studio include environment variable
15005
15006 if test "x$DEVKIT_VS_INCLUDE" = x; then
15007 eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
15008 fi
15009
15010 # The Visual Studio lib environment variable
15011
15012 if test "x$DEVKIT_VS_LIB" = x; then
15013 eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
15014 fi
15015
15016 # Corresponds to --with-msvcr-dll
15017
15018 if test "x$DEVKIT_MSVCR_DLL" = x; then
15019 eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
15020 fi
15021
15022 # Corresponds to --with-msvcp-dll
15023
15024 if test "x$DEVKIT_MSVCP_DLL" = x; then
15025 eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
15026 fi
15027
15028 fi
15029
15030 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
15031 $as_echo_n "checking for devkit... " >&6; }
15032 if test "x$DEVKIT_NAME" != x; then
15033 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
15034 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
15035 else
15036 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
15037 $as_echo "$DEVKIT_ROOT" >&6; }
15038 fi
15039
15040
15041 if test "x$DEVKIT_EXTRA_PATH" != x; then
15042 if test "x$EXTRA_PATH" = x; then
15043 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
15044 else
15045 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
15046 fi
15047 fi
15048
15049
15050 # Fallback default of just /bin if DEVKIT_PATH is not defined
15051 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
15052 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
15053 fi
15054
15055 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
15056 if test "x$TOOLCHAIN_PATH" = x; then
15057 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
15058 else
15059 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
15060 fi
15061 fi
15062
15063
15064 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
15065 # places for backwards compatiblity.
15066 if test "x$DEVKIT_SYSROOT" != x; then
15067 SYSROOT="$DEVKIT_SYSROOT"
15068 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
15069 SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
15070 elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
15071 SYSROOT="$DEVKIT_ROOT/$host/sys-root"
15072 fi
15073
15074
15075 fi
15076
15077
15078 # You can force the sysroot if the sysroot encoded into the compiler tools
15079 # is not correct.
15080
15081 # Check whether --with-sys-root was given.
15082 if test "${with_sys_root+set}" = set; then :
15083 withval=$with_sys_root; SYSROOT=$with_sys_root
15084
15085 fi
15086
15087
15088
15089 # Check whether --with-sysroot was given.
15090 if test "${with_sysroot+set}" = set; then :
15091 withval=$with_sysroot; SYSROOT=$with_sysroot
15092
15093 fi
15094
15095
15096
15097 # Check whether --with-tools-dir was given.
15098 if test "${with_tools_dir+set}" = set; then :
15099 withval=$with_tools_dir;
15100 if test "x$with_tools_dir" != x; then
15101 if test "x$TOOLCHAIN_PATH" = x; then
15102 TOOLCHAIN_PATH="$with_tools_dir"
15103 else
15104 TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
15105 fi
15106 fi
15107
15108
15109 fi
15110
15111
15112
15113 # Check whether --with-toolchain-path was given.
15114 if test "${with_toolchain_path+set}" = set; then :
15115 withval=$with_toolchain_path;
15116 if test "x$with_toolchain_path" != x; then
15117 if test "x$TOOLCHAIN_PATH" = x; then
15118 TOOLCHAIN_PATH="$with_toolchain_path"
15119 else
15120 TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15121 fi
15122 fi
15123
15124
15125 fi
15126
15127
15128
15129 # Check whether --with-extra-path was given.
15130 if test "${with_extra_path+set}" = set; then :
15131 withval=$with_extra_path;
15132 if test "x$with_extra_path" != x; then
15133 if test "x$EXTRA_PATH" = x; then
15134 EXTRA_PATH="$with_extra_path"
15135 else
15136 EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15137 fi
15138 fi
15139
15140
15141 fi
15142
15143
15144 if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
15145 # detect if Xcode is installed by running xcodebuild -version
15146 # if no Xcode installed, xcodebuild exits with 1
15147 # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
15148 if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
15149 # We need to use xcodebuild in the toolchain dir provided by the user, this will
15150 # fall back on the stub binary in /usr/bin/xcodebuild
15151 # Extract the first word of "xcodebuild", so it can be a program name with args.
15152 set dummy xcodebuild; ac_word=$2
15153 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15154 $as_echo_n "checking for $ac_word... " >&6; }
15155 if ${ac_cv_path_XCODEBUILD+:} false; then :
15156 $as_echo_n "(cached) " >&6
15157 else
15158 case $XCODEBUILD in
15159 [\\/]* | ?:[\\/]*)
15160 ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
15161 ;;
15162 *)
15163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15164 for as_dir in $TOOLCHAIN_PATH
15165 do
15166 IFS=$as_save_IFS
15167 test -z "$as_dir" && as_dir=.
15168 for ac_exec_ext in '' $ac_executable_extensions; do
15169 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15170 ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
15171 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15172 break 2
15173 fi
15174 done
15175 done
15176 IFS=$as_save_IFS
15177
15178 test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
15179 ;;
15180 esac
15181 fi
15182 XCODEBUILD=$ac_cv_path_XCODEBUILD
15183 if test -n "$XCODEBUILD"; then
15184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
15185 $as_echo "$XCODEBUILD" >&6; }
15186 else
15187 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15188 $as_echo "no" >&6; }
15189 fi
15190
15191
15192 else
15193 # this should result in SYSROOT being empty, unless --with-sysroot is provided
15194 # when only the command line tools are installed there are no SDKs, so headers
15195 # are copied into the system frameworks
15196 XCODEBUILD=
15197
15198 fi
15199
15200 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
15201 $as_echo_n "checking for sdk name... " >&6; }
15202
15203 # Check whether --with-sdk-name was given.
15204 if test "${with_sdk_name+set}" = set; then :
15205 withval=$with_sdk_name; SDKNAME=$with_sdk_name
15206
15207 fi
15208
15209 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
15210 $as_echo "$SDKNAME" >&6; }
15211
15212 # if toolchain path is specified then don't rely on system headers, they may not compile
15213 HAVE_SYSTEM_FRAMEWORK_HEADERS=0
15214 test -z "$TOOLCHAIN_PATH" && \
15215 HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
15216
15217 if test -z "$SYSROOT"; then
15218 if test -n "$XCODEBUILD"; then
15219 # if we don't have system headers, use default SDK name (last resort)
15220 if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15221 SDKNAME=${SDKNAME:-macosx}
15222 fi
15223
15224 if test -n "$SDKNAME"; then
15225 # Call xcodebuild to determine SYSROOT
15226 SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
15227 fi
15228 else
15229 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15230 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
15231 fi
15232 fi
15233 else
15234 # warn user if --with-sdk-name was also set
15235 if test -n "$with_sdk_name"; then
15236 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
15237 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
15238 fi
15239 fi
15240
15241 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
15242 # If no system framework headers, then SYSROOT must be set, or we won't build
15243 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
15244 fi
15245
15246 # Perform a basic sanity test
15247 if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
15248 if test -z "$SYSROOT"; then
15249 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
15250 else
15251 as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
15252 fi
15253 fi
15254
15255 # set SDKROOT too, Xcode tools will pick it up
15256 SDKROOT=$SYSROOT
15257
15258 fi
15259
15260 # Prepend the extra path to the global path
15261
15262 if test "x$EXTRA_PATH" != x; then
15263 if test "x$PATH" = x; then
15264 PATH="$EXTRA_PATH"
15265 else
15266 PATH="$EXTRA_PATH:$PATH"
15267 fi
15268 fi
15269
15270
15271 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15272 # Add extra search paths on solaris for utilities like ar and as etc...
15273 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15274 fi
15275
15276 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15277 $as_echo_n "checking for sysroot... " >&6; }
15278 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15279 $as_echo "$SYSROOT" >&6; }
15280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15281 $as_echo_n "checking for toolchain path... " >&6; }
15282 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15283 $as_echo "$TOOLCHAIN_PATH" >&6; }
15284 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15285 $as_echo_n "checking for extra path... " >&6; }
15286 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15287 $as_echo "$EXTRA_PATH" >&6; }
15288
15289
15290 # To properly create a configuration name, we need to have the OpenJDK target
15291 # and options (variants and debug level) parsed.
15292
15293
15294
15295 # Check whether --with-conf-name was given.
15296 if test "${with_conf_name+set}" = set; then :
15297 withval=$with_conf_name; CONF_NAME=${with_conf_name}
15298 fi
15299
15300
15301 # Test from where we are running configure, in or outside of src root.
15302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15303 $as_echo_n "checking where to store configuration... " >&6; }
15304 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15305 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15306 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15307 # We are running configure from the src root.
15308 # Create a default ./build/target-variant-debuglevel output root.
15309 if test "x${CONF_NAME}" = x; then
15310 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15311 $as_echo "in default location" >&6; }
15312 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15313 else
15314 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15315 $as_echo "in build directory with custom name" >&6; }
15316 fi
15317 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15318 $MKDIR -p "$OUTPUT_ROOT"
15319 if test ! -d "$OUTPUT_ROOT"; then
15320 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15321 fi
15322 else
15323 # We are running configure from outside of the src dir.
15324 # Then use the current directory as output dir!
15325 # If configuration is situated in normal build directory, just use the build
15326 # directory name as configuration name, otherwise use the complete path.
15327 if test "x${CONF_NAME}" = x; then
15328 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15329 fi
15330 OUTPUT_ROOT="$CURDIR"
15331 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15332 $as_echo "in current directory" >&6; }
15333
15334 # WARNING: This might be a bad thing to do. You need to be sure you want to
15335 # have a configuration in this directory. Do some sanity checks!
15336
15337 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15338 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15339 # other files
15340 files_present=`$LS $OUTPUT_ROOT`
15341 # Configure has already touched config.log and confdefs.h in the current dir when this check
15342 # is performed.
15343 filtered_files=`$ECHO "$files_present" \
15344 | $SED -e 's/config.log//g' \
15345 -e 's/configure.log//g' \
15346 -e 's/confdefs.h//g' \
15347 -e 's/ //g' \
15348 | $TR -d '\n'`
15349 if test "x$filtered_files" != x; then
15350 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15351 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15352 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15353 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15354 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15355 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15356 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15357 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15358 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15359 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15360 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15361 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15362 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15363 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15364 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15365 fi
15366 fi
15367 fi
15368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15369 $as_echo_n "checking what configuration name to use... " >&6; }
15370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15371 $as_echo "$CONF_NAME" >&6; }
15372
15373
15374 # Only process if variable expands to non-empty
15375
15376 if test "x$OUTPUT_ROOT" != x; then
15377 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15378
15379 # Input might be given as Windows format, start by converting to
15380 # unix format.
15381 path="$OUTPUT_ROOT"
15382 new_path=`$CYGPATH -u "$path"`
15383
15384 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15385 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15386 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15387 # "foo.exe" is OK but "foo" is an error.
15388 #
15389 # This test is therefore slightly more accurate than "test -f" to check for file precense.
15390 # It is also a way to make sure we got the proper file name for the real test later on.
15391 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15392 if test "x$test_shortpath" = x; then
15393 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15394 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15395 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15396 fi
15397
15398 # Call helper function which possibly converts this using DOS-style short mode.
15399 # If so, the updated path is stored in $new_path.
15400
15401 input_path="$new_path"
15402 # Check if we need to convert this using DOS-style short mode. If the path
15403 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15404 # take no chances and rewrite it.
15405 # Note: m4 eats our [], so we need to use [ and ] instead.
15406 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15407 if test "x$has_forbidden_chars" != x; then
15408 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15409 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15410 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15411 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15412 # Going to short mode and back again did indeed matter. Since short mode is
15413 # case insensitive, let's make it lowercase to improve readability.
15414 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15415 # Now convert it back to Unix-style (cygpath)
15416 input_path=`$CYGPATH -u "$shortmode_path"`
15417 new_path="$input_path"
15418 fi
15419 fi
15420
15421 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15422 if test "x$test_cygdrive_prefix" = x; then
15423 # As a simple fix, exclude /usr/bin since it's not a real path.
15424 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15425 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15426 # a path prefixed by /cygdrive for fixpath to work.
15427 new_path="$CYGWIN_ROOT_PATH$input_path"
15428 fi
15429 fi
15430
15431
15432 if test "x$path" != "x$new_path"; then
15433 OUTPUT_ROOT="$new_path"
15434 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15435 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15436 fi
15437
15438 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15439
15440 path="$OUTPUT_ROOT"
15441 has_colon=`$ECHO $path | $GREP ^.:`
15442 new_path="$path"
15443 if test "x$has_colon" = x; then
15444 # Not in mixed or Windows style, start by that.
15445 new_path=`cmd //c echo $path`
15446 fi
15447
15448
15449 input_path="$new_path"
15450 # Check if we need to convert this using DOS-style short mode. If the path
15451 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15452 # take no chances and rewrite it.
15453 # Note: m4 eats our [], so we need to use [ and ] instead.
15454 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15455 if test "x$has_forbidden_chars" != x; then
15456 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15457 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15458 fi
15459
15460
15461 windows_path="$new_path"
15462 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15463 unix_path=`$CYGPATH -u "$windows_path"`
15464 new_path="$unix_path"
15465 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15466 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15467 new_path="$unix_path"
15468 fi
15469
15470 if test "x$path" != "x$new_path"; then
15471 OUTPUT_ROOT="$new_path"
15472 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15473 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15474 fi
15475
15476 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15477 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15478
15479 else
15480 # We're on a unix platform. Hooray! :)
15481 path="$OUTPUT_ROOT"
15482 has_space=`$ECHO "$path" | $GREP " "`
15483 if test "x$has_space" != x; then
15484 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15485 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15486 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15487 fi
15488
15489 # Use eval to expand a potential ~
15490 eval path="$path"
15491 if test ! -f "$path" && test ! -d "$path"; then
15492 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15493 fi
15494
15495 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15496 fi
15497 fi
15498
15499
15500 CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
15501 $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
15502
15503 SPEC=$OUTPUT_ROOT/spec.gmk
15504
15505 CONF_NAME=$CONF_NAME
15506
15507 OUTPUT_ROOT=$OUTPUT_ROOT
15508
15509
15510
15511 # The spec.gmk file contains all variables for the make system.
15512 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15513
15514 # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15515 ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15516
15517 # The bootcycle-spec.gmk file contains support for boot cycle builds.
15518 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15519
15520 # The compare.sh is used to compare the build output to other builds.
15521 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15522
15523 # The generated Makefile knows where the spec.gmk is and where the source is.
15524 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15525 # which will look for generated configurations
15526 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15527
15528
15529
15530 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15531
15532 for ac_prog in apt-get yum port pkgutil pkgadd
15533 do
15534 # Extract the first word of "$ac_prog", so it can be a program name with args.
15535 set dummy $ac_prog; ac_word=$2
15536 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15537 $as_echo_n "checking for $ac_word... " >&6; }
15538 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15539 $as_echo_n "(cached) " >&6
15540 else
15541 if test -n "$PKGHANDLER"; then
15542 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15543 else
15544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15545 for as_dir in $PATH
15546 do
15547 IFS=$as_save_IFS
15548 test -z "$as_dir" && as_dir=.
15549 for ac_exec_ext in '' $ac_executable_extensions; do
15550 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15551 ac_cv_prog_PKGHANDLER="$ac_prog"
15552 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15553 break 2
15554 fi
15555 done
15556 done
15557 IFS=$as_save_IFS
15558
15559 fi
15560 fi
15561 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15562 if test -n "$PKGHANDLER"; then
15563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15564 $as_echo "$PKGHANDLER" >&6; }
15565 else
15566 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15567 $as_echo "no" >&6; }
15568 fi
15569
15570
15571 test -n "$PKGHANDLER" && break
15572 done
15573
15574
15575
15576 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15577
15578
15579 # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15580 if test "x$MAKE" != x; then
15581 # User has supplied a make, test it.
15582 if test ! -f "$MAKE"; then
15583 as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15584 fi
15585
15586 MAKE_CANDIDATE=""$MAKE""
15587 DESCRIPTION="user supplied MAKE=$MAKE"
15588
15589 # On Cygwin, we require a newer version of make than on other platforms
15590 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15591 MAKE_VERSION_EXPR="-e 4\."
15592 MAKE_REQUIRED_VERSION="4.0"
15593 else
15594 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
15595 MAKE_REQUIRED_VERSION="3.81"
15596 fi
15597
15598 if test "x$MAKE_CANDIDATE" != x; then
15599 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15600 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15601 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15602 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15603 if test "x$IS_GNU_MAKE" = x; then
15604 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15605 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15606 else
15607 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
15608 if test "x$IS_MODERN_MAKE" = x; then
15609 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15610 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15611 else
15612 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15613 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15614 MAKE_EXPECTED_ENV='cygwin'
15615 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15616 MAKE_EXPECTED_ENV='msys'
15617 else
15618 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15619 fi
15620 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15621 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15622 else
15623 # Not relevant for non-Windows
15624 IS_MAKE_CORRECT_ENV=true
15625 fi
15626 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15627 { $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
15628 $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;}
15629 else
15630 FOUND_MAKE=$MAKE_CANDIDATE
15631
15632 # Only process if variable expands to non-empty
15633
15634 if test "x$FOUND_MAKE" != x; then
15635 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15636
15637 # First separate the path from the arguments. This will split at the first
15638 # space.
15639 complete="$FOUND_MAKE"
15640 path="${complete%% *}"
15641 tmp="$complete EOL"
15642 arguments="${tmp#* }"
15643
15644 # Input might be given as Windows format, start by converting to
15645 # unix format.
15646 new_path=`$CYGPATH -u "$path"`
15647
15648 # Now try to locate executable using which
15649 new_path=`$WHICH "$new_path" 2> /dev/null`
15650 # bat and cmd files are not always considered executable in cygwin causing which
15651 # to not find them
15652 if test "x$new_path" = x \
15653 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15654 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15655 new_path=`$CYGPATH -u "$path"`
15656 fi
15657 if test "x$new_path" = x; then
15658 # Oops. Which didn't find the executable.
15659 # The splitting of arguments from the executable at a space might have been incorrect,
15660 # since paths with space are more likely in Windows. Give it another try with the whole
15661 # argument.
15662 path="$complete"
15663 arguments="EOL"
15664 new_path=`$CYGPATH -u "$path"`
15665 new_path=`$WHICH "$new_path" 2> /dev/null`
15666 # bat and cmd files are not always considered executable in cygwin causing which
15667 # to not find them
15668 if test "x$new_path" = x \
15669 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15670 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15671 new_path=`$CYGPATH -u "$path"`
15672 fi
15673 if test "x$new_path" = x; then
15674 # It's still not found. Now this is an unrecoverable error.
15675 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15676 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15677 has_space=`$ECHO "$complete" | $GREP " "`
15678 if test "x$has_space" != x; then
15679 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15680 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15681 fi
15682 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15683 fi
15684 fi
15685
15686 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15687 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15688 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15689 # "foo.exe" is OK but "foo" is an error.
15690 #
15691 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15692 # It is also a way to make sure we got the proper file name for the real test later on.
15693 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15694 if test "x$test_shortpath" = x; then
15695 # Short path failed, file does not exist as specified.
15696 # Try adding .exe or .cmd
15697 if test -f "${new_path}.exe"; then
15698 input_to_shortpath="${new_path}.exe"
15699 elif test -f "${new_path}.cmd"; then
15700 input_to_shortpath="${new_path}.cmd"
15701 else
15702 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15703 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15704 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15705 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15706 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15707 fi
15708 else
15709 input_to_shortpath="$new_path"
15710 fi
15711
15712 # Call helper function which possibly converts this using DOS-style short mode.
15713 # If so, the updated path is stored in $new_path.
15714 new_path="$input_to_shortpath"
15715
15716 input_path="$input_to_shortpath"
15717 # Check if we need to convert this using DOS-style short mode. If the path
15718 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15719 # take no chances and rewrite it.
15720 # Note: m4 eats our [], so we need to use [ and ] instead.
15721 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15722 if test "x$has_forbidden_chars" != x; then
15723 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15724 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15725 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15726 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15727 # Going to short mode and back again did indeed matter. Since short mode is
15728 # case insensitive, let's make it lowercase to improve readability.
15729 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15730 # Now convert it back to Unix-style (cygpath)
15731 input_path=`$CYGPATH -u "$shortmode_path"`
15732 new_path="$input_path"
15733 fi
15734 fi
15735
15736 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15737 if test "x$test_cygdrive_prefix" = x; then
15738 # As a simple fix, exclude /usr/bin since it's not a real path.
15739 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15740 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15741 # a path prefixed by /cygdrive for fixpath to work.
15742 new_path="$CYGWIN_ROOT_PATH$input_path"
15743 fi
15744 fi
15745
15746 # remove trailing .exe if any
15747 new_path="${new_path/%.exe/}"
15748
15749 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15750
15751 # First separate the path from the arguments. This will split at the first
15752 # space.
15753 complete="$FOUND_MAKE"
15754 path="${complete%% *}"
15755 tmp="$complete EOL"
15756 arguments="${tmp#* }"
15757
15758 # Input might be given as Windows format, start by converting to
15759 # unix format.
15760 new_path="$path"
15761
15762 windows_path="$new_path"
15763 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15764 unix_path=`$CYGPATH -u "$windows_path"`
15765 new_path="$unix_path"
15766 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15767 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15768 new_path="$unix_path"
15769 fi
15770
15771
15772 # Now try to locate executable using which
15773 new_path=`$WHICH "$new_path" 2> /dev/null`
15774
15775 if test "x$new_path" = x; then
15776 # Oops. Which didn't find the executable.
15777 # The splitting of arguments from the executable at a space might have been incorrect,
15778 # since paths with space are more likely in Windows. Give it another try with the whole
15779 # argument.
15780 path="$complete"
15781 arguments="EOL"
15782 new_path="$path"
15783
15784 windows_path="$new_path"
15785 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15786 unix_path=`$CYGPATH -u "$windows_path"`
15787 new_path="$unix_path"
15788 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15789 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15790 new_path="$unix_path"
15791 fi
15792
15793
15794 new_path=`$WHICH "$new_path" 2> /dev/null`
15795 # bat and cmd files are not always considered executable in MSYS causing which
15796 # to not find them
15797 if test "x$new_path" = x \
15798 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15799 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15800 new_path="$path"
15801
15802 windows_path="$new_path"
15803 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15804 unix_path=`$CYGPATH -u "$windows_path"`
15805 new_path="$unix_path"
15806 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15807 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15808 new_path="$unix_path"
15809 fi
15810
15811 fi
15812
15813 if test "x$new_path" = x; then
15814 # It's still not found. Now this is an unrecoverable error.
15815 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15816 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15817 has_space=`$ECHO "$complete" | $GREP " "`
15818 if test "x$has_space" != x; then
15819 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15820 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15821 fi
15822 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15823 fi
15824 fi
15825
15826 # Now new_path has a complete unix path to the binary
15827 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15828 # Keep paths in /bin as-is, but remove trailing .exe if any
15829 new_path="${new_path/%.exe/}"
15830 # Do not save /bin paths to all_fixpath_prefixes!
15831 else
15832 # Not in mixed or Windows style, start by that.
15833 new_path=`cmd //c echo $new_path`
15834
15835 input_path="$new_path"
15836 # Check if we need to convert this using DOS-style short mode. If the path
15837 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15838 # take no chances and rewrite it.
15839 # Note: m4 eats our [], so we need to use [ and ] instead.
15840 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15841 if test "x$has_forbidden_chars" != x; then
15842 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15843 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15844 fi
15845
15846 # Output is in $new_path
15847
15848 windows_path="$new_path"
15849 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15850 unix_path=`$CYGPATH -u "$windows_path"`
15851 new_path="$unix_path"
15852 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15853 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15854 new_path="$unix_path"
15855 fi
15856
15857 # remove trailing .exe if any
15858 new_path="${new_path/%.exe/}"
15859
15860 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15861 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15862 fi
15863
15864 else
15865 # We're on a unix platform. Hooray! :)
15866 # First separate the path from the arguments. This will split at the first
15867 # space.
15868 complete="$FOUND_MAKE"
15869 path="${complete%% *}"
15870 tmp="$complete EOL"
15871 arguments="${tmp#* }"
15872
15873 # Cannot rely on the command "which" here since it doesn't always work.
15874 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15875 if test -z "$is_absolute_path"; then
15876 # Path to executable is not absolute. Find it.
15877 IFS_save="$IFS"
15878 IFS=:
15879 for p in $PATH; do
15880 if test -f "$p/$path" && test -x "$p/$path"; then
15881 new_path="$p/$path"
15882 break
15883 fi
15884 done
15885 IFS="$IFS_save"
15886 else
15887 # This is an absolute path, we can use it without further modifications.
15888 new_path="$path"
15889 fi
15890
15891 if test "x$new_path" = x; then
15892 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15893 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15894 has_space=`$ECHO "$complete" | $GREP " "`
15895 if test "x$has_space" != x; then
15896 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15897 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15898 fi
15899 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15900 fi
15901 fi
15902
15903 # Now join together the path and the arguments once again
15904 if test "x$arguments" != xEOL; then
15905 new_complete="$new_path ${arguments% *}"
15906 else
15907 new_complete="$new_path"
15908 fi
15909
15910 if test "x$complete" != "x$new_complete"; then
15911 FOUND_MAKE="$new_complete"
15912 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15913 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15914 fi
15915 fi
15916
15917 fi
15918 fi
15919 fi
15920 fi
15921
15922 if test "x$FOUND_MAKE" = x; then
15923 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
15924 fi
15925 else
15926 # Try our hardest to locate a correct version of GNU make
15927 for ac_prog in gmake
15928 do
15929 # Extract the first word of "$ac_prog", so it can be a program name with args.
15930 set dummy $ac_prog; ac_word=$2
15931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15932 $as_echo_n "checking for $ac_word... " >&6; }
15933 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15934 $as_echo_n "(cached) " >&6
15935 else
15936 case $CHECK_GMAKE in
15937 [\\/]* | ?:[\\/]*)
15938 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15939 ;;
15940 *)
15941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15942 for as_dir in $PATH
15943 do
15944 IFS=$as_save_IFS
15945 test -z "$as_dir" && as_dir=.
15946 for ac_exec_ext in '' $ac_executable_extensions; do
15947 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15948 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15949 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15950 break 2
15951 fi
15952 done
15953 done
15954 IFS=$as_save_IFS
15955
15956 ;;
15957 esac
15958 fi
15959 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15960 if test -n "$CHECK_GMAKE"; then
15961 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15962 $as_echo "$CHECK_GMAKE" >&6; }
15963 else
15964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15965 $as_echo "no" >&6; }
15966 fi
15967
15968
15969 test -n "$CHECK_GMAKE" && break
15970 done
15971
15972
15973 MAKE_CANDIDATE=""$CHECK_GMAKE""
15974 DESCRIPTION="gmake in PATH"
15975
15976 # On Cygwin, we require a newer version of make than on other platforms
15977 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15978 MAKE_VERSION_EXPR="-e 4\."
15979 MAKE_REQUIRED_VERSION="4.0"
15980 else
15981 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
15982 MAKE_REQUIRED_VERSION="3.81"
15983 fi
15984
15985 if test "x$MAKE_CANDIDATE" != x; then
15986 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15987 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15988 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15989 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15990 if test "x$IS_GNU_MAKE" = x; then
15991 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15992 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15993 else
15994 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
15995 if test "x$IS_MODERN_MAKE" = x; then
15996 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15997 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15998 else
15999 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16000 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16001 MAKE_EXPECTED_ENV='cygwin'
16002 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16003 MAKE_EXPECTED_ENV='msys'
16004 else
16005 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16006 fi
16007 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16008 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16009 else
16010 # Not relevant for non-Windows
16011 IS_MAKE_CORRECT_ENV=true
16012 fi
16013 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16014 { $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
16015 $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;}
16016 else
16017 FOUND_MAKE=$MAKE_CANDIDATE
16018
16019 # Only process if variable expands to non-empty
16020
16021 if test "x$FOUND_MAKE" != x; then
16022 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16023
16024 # First separate the path from the arguments. This will split at the first
16025 # space.
16026 complete="$FOUND_MAKE"
16027 path="${complete%% *}"
16028 tmp="$complete EOL"
16029 arguments="${tmp#* }"
16030
16031 # Input might be given as Windows format, start by converting to
16032 # unix format.
16033 new_path=`$CYGPATH -u "$path"`
16034
16035 # Now try to locate executable using which
16036 new_path=`$WHICH "$new_path" 2> /dev/null`
16037 # bat and cmd files are not always considered executable in cygwin causing which
16038 # to not find them
16039 if test "x$new_path" = x \
16040 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16041 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16042 new_path=`$CYGPATH -u "$path"`
16043 fi
16044 if test "x$new_path" = x; then
16045 # Oops. Which didn't find the executable.
16046 # The splitting of arguments from the executable at a space might have been incorrect,
16047 # since paths with space are more likely in Windows. Give it another try with the whole
16048 # argument.
16049 path="$complete"
16050 arguments="EOL"
16051 new_path=`$CYGPATH -u "$path"`
16052 new_path=`$WHICH "$new_path" 2> /dev/null`
16053 # bat and cmd files are not always considered executable in cygwin causing which
16054 # to not find them
16055 if test "x$new_path" = x \
16056 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16057 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16058 new_path=`$CYGPATH -u "$path"`
16059 fi
16060 if test "x$new_path" = x; then
16061 # It's still not found. Now this is an unrecoverable error.
16062 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16063 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16064 has_space=`$ECHO "$complete" | $GREP " "`
16065 if test "x$has_space" != x; then
16066 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16067 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16068 fi
16069 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16070 fi
16071 fi
16072
16073 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16074 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16075 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16076 # "foo.exe" is OK but "foo" is an error.
16077 #
16078 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16079 # It is also a way to make sure we got the proper file name for the real test later on.
16080 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16081 if test "x$test_shortpath" = x; then
16082 # Short path failed, file does not exist as specified.
16083 # Try adding .exe or .cmd
16084 if test -f "${new_path}.exe"; then
16085 input_to_shortpath="${new_path}.exe"
16086 elif test -f "${new_path}.cmd"; then
16087 input_to_shortpath="${new_path}.cmd"
16088 else
16089 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16090 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16091 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16092 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16093 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16094 fi
16095 else
16096 input_to_shortpath="$new_path"
16097 fi
16098
16099 # Call helper function which possibly converts this using DOS-style short mode.
16100 # If so, the updated path is stored in $new_path.
16101 new_path="$input_to_shortpath"
16102
16103 input_path="$input_to_shortpath"
16104 # Check if we need to convert this using DOS-style short mode. If the path
16105 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16106 # take no chances and rewrite it.
16107 # Note: m4 eats our [], so we need to use [ and ] instead.
16108 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16109 if test "x$has_forbidden_chars" != x; then
16110 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16111 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16112 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16113 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16114 # Going to short mode and back again did indeed matter. Since short mode is
16115 # case insensitive, let's make it lowercase to improve readability.
16116 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16117 # Now convert it back to Unix-style (cygpath)
16118 input_path=`$CYGPATH -u "$shortmode_path"`
16119 new_path="$input_path"
16120 fi
16121 fi
16122
16123 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16124 if test "x$test_cygdrive_prefix" = x; then
16125 # As a simple fix, exclude /usr/bin since it's not a real path.
16126 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16127 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16128 # a path prefixed by /cygdrive for fixpath to work.
16129 new_path="$CYGWIN_ROOT_PATH$input_path"
16130 fi
16131 fi
16132
16133 # remove trailing .exe if any
16134 new_path="${new_path/%.exe/}"
16135
16136 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16137
16138 # First separate the path from the arguments. This will split at the first
16139 # space.
16140 complete="$FOUND_MAKE"
16141 path="${complete%% *}"
16142 tmp="$complete EOL"
16143 arguments="${tmp#* }"
16144
16145 # Input might be given as Windows format, start by converting to
16146 # unix format.
16147 new_path="$path"
16148
16149 windows_path="$new_path"
16150 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16151 unix_path=`$CYGPATH -u "$windows_path"`
16152 new_path="$unix_path"
16153 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16154 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16155 new_path="$unix_path"
16156 fi
16157
16158
16159 # Now try to locate executable using which
16160 new_path=`$WHICH "$new_path" 2> /dev/null`
16161
16162 if test "x$new_path" = x; then
16163 # Oops. Which didn't find the executable.
16164 # The splitting of arguments from the executable at a space might have been incorrect,
16165 # since paths with space are more likely in Windows. Give it another try with the whole
16166 # argument.
16167 path="$complete"
16168 arguments="EOL"
16169 new_path="$path"
16170
16171 windows_path="$new_path"
16172 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16173 unix_path=`$CYGPATH -u "$windows_path"`
16174 new_path="$unix_path"
16175 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16176 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16177 new_path="$unix_path"
16178 fi
16179
16180
16181 new_path=`$WHICH "$new_path" 2> /dev/null`
16182 # bat and cmd files are not always considered executable in MSYS causing which
16183 # to not find them
16184 if test "x$new_path" = x \
16185 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16186 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16187 new_path="$path"
16188
16189 windows_path="$new_path"
16190 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16191 unix_path=`$CYGPATH -u "$windows_path"`
16192 new_path="$unix_path"
16193 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16194 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16195 new_path="$unix_path"
16196 fi
16197
16198 fi
16199
16200 if test "x$new_path" = x; then
16201 # It's still not found. Now this is an unrecoverable error.
16202 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16203 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16204 has_space=`$ECHO "$complete" | $GREP " "`
16205 if test "x$has_space" != x; then
16206 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16207 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16208 fi
16209 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16210 fi
16211 fi
16212
16213 # Now new_path has a complete unix path to the binary
16214 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16215 # Keep paths in /bin as-is, but remove trailing .exe if any
16216 new_path="${new_path/%.exe/}"
16217 # Do not save /bin paths to all_fixpath_prefixes!
16218 else
16219 # Not in mixed or Windows style, start by that.
16220 new_path=`cmd //c echo $new_path`
16221
16222 input_path="$new_path"
16223 # Check if we need to convert this using DOS-style short mode. If the path
16224 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16225 # take no chances and rewrite it.
16226 # Note: m4 eats our [], so we need to use [ and ] instead.
16227 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16228 if test "x$has_forbidden_chars" != x; then
16229 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16230 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16231 fi
16232
16233 # Output is in $new_path
16234
16235 windows_path="$new_path"
16236 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16237 unix_path=`$CYGPATH -u "$windows_path"`
16238 new_path="$unix_path"
16239 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16240 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16241 new_path="$unix_path"
16242 fi
16243
16244 # remove trailing .exe if any
16245 new_path="${new_path/%.exe/}"
16246
16247 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16248 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16249 fi
16250
16251 else
16252 # We're on a unix platform. Hooray! :)
16253 # First separate the path from the arguments. This will split at the first
16254 # space.
16255 complete="$FOUND_MAKE"
16256 path="${complete%% *}"
16257 tmp="$complete EOL"
16258 arguments="${tmp#* }"
16259
16260 # Cannot rely on the command "which" here since it doesn't always work.
16261 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16262 if test -z "$is_absolute_path"; then
16263 # Path to executable is not absolute. Find it.
16264 IFS_save="$IFS"
16265 IFS=:
16266 for p in $PATH; do
16267 if test -f "$p/$path" && test -x "$p/$path"; then
16268 new_path="$p/$path"
16269 break
16270 fi
16271 done
16272 IFS="$IFS_save"
16273 else
16274 # This is an absolute path, we can use it without further modifications.
16275 new_path="$path"
16276 fi
16277
16278 if test "x$new_path" = x; then
16279 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16280 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16281 has_space=`$ECHO "$complete" | $GREP " "`
16282 if test "x$has_space" != x; then
16283 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16284 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16285 fi
16286 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16287 fi
16288 fi
16289
16290 # Now join together the path and the arguments once again
16291 if test "x$arguments" != xEOL; then
16292 new_complete="$new_path ${arguments% *}"
16293 else
16294 new_complete="$new_path"
16295 fi
16296
16297 if test "x$complete" != "x$new_complete"; then
16298 FOUND_MAKE="$new_complete"
16299 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16300 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16301 fi
16302 fi
16303
16304 fi
16305 fi
16306 fi
16307 fi
16308
16309
16310 if test "x$FOUND_MAKE" = x; then
16311 for ac_prog in make
16312 do
16313 # Extract the first word of "$ac_prog", so it can be a program name with args.
16314 set dummy $ac_prog; ac_word=$2
16315 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16316 $as_echo_n "checking for $ac_word... " >&6; }
16317 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16318 $as_echo_n "(cached) " >&6
16319 else
16320 case $CHECK_MAKE in
16321 [\\/]* | ?:[\\/]*)
16322 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16323 ;;
16324 *)
16325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16326 for as_dir in $PATH
16327 do
16328 IFS=$as_save_IFS
16329 test -z "$as_dir" && as_dir=.
16330 for ac_exec_ext in '' $ac_executable_extensions; do
16331 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16332 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16333 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16334 break 2
16335 fi
16336 done
16337 done
16338 IFS=$as_save_IFS
16339
16340 ;;
16341 esac
16342 fi
16343 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16344 if test -n "$CHECK_MAKE"; then
16345 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16346 $as_echo "$CHECK_MAKE" >&6; }
16347 else
16348 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16349 $as_echo "no" >&6; }
16350 fi
16351
16352
16353 test -n "$CHECK_MAKE" && break
16354 done
16355
16356
16357 MAKE_CANDIDATE=""$CHECK_MAKE""
16358 DESCRIPTION="make in PATH"
16359
16360 # On Cygwin, we require a newer version of make than on other platforms
16361 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16362 MAKE_VERSION_EXPR="-e 4\."
16363 MAKE_REQUIRED_VERSION="4.0"
16364 else
16365 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16366 MAKE_REQUIRED_VERSION="3.81"
16367 fi
16368
16369 if test "x$MAKE_CANDIDATE" != x; then
16370 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16371 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16372 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16373 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16374 if test "x$IS_GNU_MAKE" = x; then
16375 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16376 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16377 else
16378 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16379 if test "x$IS_MODERN_MAKE" = x; then
16380 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16381 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16382 else
16383 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16384 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16385 MAKE_EXPECTED_ENV='cygwin'
16386 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16387 MAKE_EXPECTED_ENV='msys'
16388 else
16389 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16390 fi
16391 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16392 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16393 else
16394 # Not relevant for non-Windows
16395 IS_MAKE_CORRECT_ENV=true
16396 fi
16397 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16398 { $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
16399 $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;}
16400 else
16401 FOUND_MAKE=$MAKE_CANDIDATE
16402
16403 # Only process if variable expands to non-empty
16404
16405 if test "x$FOUND_MAKE" != x; then
16406 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16407
16408 # First separate the path from the arguments. This will split at the first
16409 # space.
16410 complete="$FOUND_MAKE"
16411 path="${complete%% *}"
16412 tmp="$complete EOL"
16413 arguments="${tmp#* }"
16414
16415 # Input might be given as Windows format, start by converting to
16416 # unix format.
16417 new_path=`$CYGPATH -u "$path"`
16418
16419 # Now try to locate executable using which
16420 new_path=`$WHICH "$new_path" 2> /dev/null`
16421 # bat and cmd files are not always considered executable in cygwin causing which
16422 # to not find them
16423 if test "x$new_path" = x \
16424 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16425 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16426 new_path=`$CYGPATH -u "$path"`
16427 fi
16428 if test "x$new_path" = x; then
16429 # Oops. Which didn't find the executable.
16430 # The splitting of arguments from the executable at a space might have been incorrect,
16431 # since paths with space are more likely in Windows. Give it another try with the whole
16432 # argument.
16433 path="$complete"
16434 arguments="EOL"
16435 new_path=`$CYGPATH -u "$path"`
16436 new_path=`$WHICH "$new_path" 2> /dev/null`
16437 # bat and cmd files are not always considered executable in cygwin causing which
16438 # to not find them
16439 if test "x$new_path" = x \
16440 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16441 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16442 new_path=`$CYGPATH -u "$path"`
16443 fi
16444 if test "x$new_path" = x; then
16445 # It's still not found. Now this is an unrecoverable error.
16446 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16447 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16448 has_space=`$ECHO "$complete" | $GREP " "`
16449 if test "x$has_space" != x; then
16450 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16451 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16452 fi
16453 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16454 fi
16455 fi
16456
16457 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16458 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16459 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16460 # "foo.exe" is OK but "foo" is an error.
16461 #
16462 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16463 # It is also a way to make sure we got the proper file name for the real test later on.
16464 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16465 if test "x$test_shortpath" = x; then
16466 # Short path failed, file does not exist as specified.
16467 # Try adding .exe or .cmd
16468 if test -f "${new_path}.exe"; then
16469 input_to_shortpath="${new_path}.exe"
16470 elif test -f "${new_path}.cmd"; then
16471 input_to_shortpath="${new_path}.cmd"
16472 else
16473 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16474 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16475 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16476 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16477 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16478 fi
16479 else
16480 input_to_shortpath="$new_path"
16481 fi
16482
16483 # Call helper function which possibly converts this using DOS-style short mode.
16484 # If so, the updated path is stored in $new_path.
16485 new_path="$input_to_shortpath"
16486
16487 input_path="$input_to_shortpath"
16488 # Check if we need to convert this using DOS-style short mode. If the path
16489 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16490 # take no chances and rewrite it.
16491 # Note: m4 eats our [], so we need to use [ and ] instead.
16492 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16493 if test "x$has_forbidden_chars" != x; then
16494 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16495 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16496 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16497 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16498 # Going to short mode and back again did indeed matter. Since short mode is
16499 # case insensitive, let's make it lowercase to improve readability.
16500 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16501 # Now convert it back to Unix-style (cygpath)
16502 input_path=`$CYGPATH -u "$shortmode_path"`
16503 new_path="$input_path"
16504 fi
16505 fi
16506
16507 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16508 if test "x$test_cygdrive_prefix" = x; then
16509 # As a simple fix, exclude /usr/bin since it's not a real path.
16510 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16511 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16512 # a path prefixed by /cygdrive for fixpath to work.
16513 new_path="$CYGWIN_ROOT_PATH$input_path"
16514 fi
16515 fi
16516
16517 # remove trailing .exe if any
16518 new_path="${new_path/%.exe/}"
16519
16520 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16521
16522 # First separate the path from the arguments. This will split at the first
16523 # space.
16524 complete="$FOUND_MAKE"
16525 path="${complete%% *}"
16526 tmp="$complete EOL"
16527 arguments="${tmp#* }"
16528
16529 # Input might be given as Windows format, start by converting to
16530 # unix format.
16531 new_path="$path"
16532
16533 windows_path="$new_path"
16534 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16535 unix_path=`$CYGPATH -u "$windows_path"`
16536 new_path="$unix_path"
16537 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16538 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16539 new_path="$unix_path"
16540 fi
16541
16542
16543 # Now try to locate executable using which
16544 new_path=`$WHICH "$new_path" 2> /dev/null`
16545
16546 if test "x$new_path" = x; then
16547 # Oops. Which didn't find the executable.
16548 # The splitting of arguments from the executable at a space might have been incorrect,
16549 # since paths with space are more likely in Windows. Give it another try with the whole
16550 # argument.
16551 path="$complete"
16552 arguments="EOL"
16553 new_path="$path"
16554
16555 windows_path="$new_path"
16556 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16557 unix_path=`$CYGPATH -u "$windows_path"`
16558 new_path="$unix_path"
16559 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16560 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16561 new_path="$unix_path"
16562 fi
16563
16564
16565 new_path=`$WHICH "$new_path" 2> /dev/null`
16566 # bat and cmd files are not always considered executable in MSYS causing which
16567 # to not find them
16568 if test "x$new_path" = x \
16569 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16570 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16571 new_path="$path"
16572
16573 windows_path="$new_path"
16574 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16575 unix_path=`$CYGPATH -u "$windows_path"`
16576 new_path="$unix_path"
16577 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16578 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16579 new_path="$unix_path"
16580 fi
16581
16582 fi
16583
16584 if test "x$new_path" = x; then
16585 # It's still not found. Now this is an unrecoverable error.
16586 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16587 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16588 has_space=`$ECHO "$complete" | $GREP " "`
16589 if test "x$has_space" != x; then
16590 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16591 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16592 fi
16593 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16594 fi
16595 fi
16596
16597 # Now new_path has a complete unix path to the binary
16598 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16599 # Keep paths in /bin as-is, but remove trailing .exe if any
16600 new_path="${new_path/%.exe/}"
16601 # Do not save /bin paths to all_fixpath_prefixes!
16602 else
16603 # Not in mixed or Windows style, start by that.
16604 new_path=`cmd //c echo $new_path`
16605
16606 input_path="$new_path"
16607 # Check if we need to convert this using DOS-style short mode. If the path
16608 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16609 # take no chances and rewrite it.
16610 # Note: m4 eats our [], so we need to use [ and ] instead.
16611 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16612 if test "x$has_forbidden_chars" != x; then
16613 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16614 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16615 fi
16616
16617 # Output is in $new_path
16618
16619 windows_path="$new_path"
16620 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16621 unix_path=`$CYGPATH -u "$windows_path"`
16622 new_path="$unix_path"
16623 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16624 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16625 new_path="$unix_path"
16626 fi
16627
16628 # remove trailing .exe if any
16629 new_path="${new_path/%.exe/}"
16630
16631 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16632 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16633 fi
16634
16635 else
16636 # We're on a unix platform. Hooray! :)
16637 # First separate the path from the arguments. This will split at the first
16638 # space.
16639 complete="$FOUND_MAKE"
16640 path="${complete%% *}"
16641 tmp="$complete EOL"
16642 arguments="${tmp#* }"
16643
16644 # Cannot rely on the command "which" here since it doesn't always work.
16645 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16646 if test -z "$is_absolute_path"; then
16647 # Path to executable is not absolute. Find it.
16648 IFS_save="$IFS"
16649 IFS=:
16650 for p in $PATH; do
16651 if test -f "$p/$path" && test -x "$p/$path"; then
16652 new_path="$p/$path"
16653 break
16654 fi
16655 done
16656 IFS="$IFS_save"
16657 else
16658 # This is an absolute path, we can use it without further modifications.
16659 new_path="$path"
16660 fi
16661
16662 if test "x$new_path" = x; then
16663 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16664 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16665 has_space=`$ECHO "$complete" | $GREP " "`
16666 if test "x$has_space" != x; then
16667 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16668 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16669 fi
16670 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16671 fi
16672 fi
16673
16674 # Now join together the path and the arguments once again
16675 if test "x$arguments" != xEOL; then
16676 new_complete="$new_path ${arguments% *}"
16677 else
16678 new_complete="$new_path"
16679 fi
16680
16681 if test "x$complete" != "x$new_complete"; then
16682 FOUND_MAKE="$new_complete"
16683 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16684 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16685 fi
16686 fi
16687
16688 fi
16689 fi
16690 fi
16691 fi
16692
16693 fi
16694
16695 if test "x$FOUND_MAKE" = x; then
16696 if test "x$TOOLCHAIN_PATH" != x; then
16697 # We have a toolchain path, check that as well before giving up.
16698 OLD_PATH=$PATH
16699 PATH=$TOOLCHAIN_PATH:$PATH
16700 for ac_prog in gmake
16701 do
16702 # Extract the first word of "$ac_prog", so it can be a program name with args.
16703 set dummy $ac_prog; ac_word=$2
16704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16705 $as_echo_n "checking for $ac_word... " >&6; }
16706 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16707 $as_echo_n "(cached) " >&6
16708 else
16709 case $CHECK_TOOLSDIR_GMAKE in
16710 [\\/]* | ?:[\\/]*)
16711 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16712 ;;
16713 *)
16714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16715 for as_dir in $PATH
16716 do
16717 IFS=$as_save_IFS
16718 test -z "$as_dir" && as_dir=.
16719 for ac_exec_ext in '' $ac_executable_extensions; do
16720 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16721 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16722 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16723 break 2
16724 fi
16725 done
16726 done
16727 IFS=$as_save_IFS
16728
16729 ;;
16730 esac
16731 fi
16732 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16733 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16735 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16736 else
16737 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16738 $as_echo "no" >&6; }
16739 fi
16740
16741
16742 test -n "$CHECK_TOOLSDIR_GMAKE" && break
16743 done
16744
16745
16746 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16747 DESCRIPTION="gmake in tools-dir"
16748
16749 # On Cygwin, we require a newer version of make than on other platforms
16750 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16751 MAKE_VERSION_EXPR="-e 4\."
16752 MAKE_REQUIRED_VERSION="4.0"
16753 else
16754 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16755 MAKE_REQUIRED_VERSION="3.81"
16756 fi
16757
16758 if test "x$MAKE_CANDIDATE" != x; then
16759 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16760 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16761 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16762 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16763 if test "x$IS_GNU_MAKE" = x; then
16764 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16765 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16766 else
16767 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16768 if test "x$IS_MODERN_MAKE" = x; then
16769 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16770 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16771 else
16772 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16773 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16774 MAKE_EXPECTED_ENV='cygwin'
16775 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16776 MAKE_EXPECTED_ENV='msys'
16777 else
16778 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16779 fi
16780 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16781 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16782 else
16783 # Not relevant for non-Windows
16784 IS_MAKE_CORRECT_ENV=true
16785 fi
16786 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16787 { $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
16788 $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;}
16789 else
16790 FOUND_MAKE=$MAKE_CANDIDATE
16791
16792 # Only process if variable expands to non-empty
16793
16794 if test "x$FOUND_MAKE" != x; then
16795 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16796
16797 # First separate the path from the arguments. This will split at the first
16798 # space.
16799 complete="$FOUND_MAKE"
16800 path="${complete%% *}"
16801 tmp="$complete EOL"
16802 arguments="${tmp#* }"
16803
16804 # Input might be given as Windows format, start by converting to
16805 # unix format.
16806 new_path=`$CYGPATH -u "$path"`
16807
16808 # Now try to locate executable using which
16809 new_path=`$WHICH "$new_path" 2> /dev/null`
16810 # bat and cmd files are not always considered executable in cygwin causing which
16811 # to not find them
16812 if test "x$new_path" = x \
16813 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16814 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16815 new_path=`$CYGPATH -u "$path"`
16816 fi
16817 if test "x$new_path" = x; then
16818 # Oops. Which didn't find the executable.
16819 # The splitting of arguments from the executable at a space might have been incorrect,
16820 # since paths with space are more likely in Windows. Give it another try with the whole
16821 # argument.
16822 path="$complete"
16823 arguments="EOL"
16824 new_path=`$CYGPATH -u "$path"`
16825 new_path=`$WHICH "$new_path" 2> /dev/null`
16826 # bat and cmd files are not always considered executable in cygwin causing which
16827 # to not find them
16828 if test "x$new_path" = x \
16829 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16830 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16831 new_path=`$CYGPATH -u "$path"`
16832 fi
16833 if test "x$new_path" = x; then
16834 # It's still not found. Now this is an unrecoverable error.
16835 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16836 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16837 has_space=`$ECHO "$complete" | $GREP " "`
16838 if test "x$has_space" != x; then
16839 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16840 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16841 fi
16842 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16843 fi
16844 fi
16845
16846 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16847 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16848 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16849 # "foo.exe" is OK but "foo" is an error.
16850 #
16851 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16852 # It is also a way to make sure we got the proper file name for the real test later on.
16853 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16854 if test "x$test_shortpath" = x; then
16855 # Short path failed, file does not exist as specified.
16856 # Try adding .exe or .cmd
16857 if test -f "${new_path}.exe"; then
16858 input_to_shortpath="${new_path}.exe"
16859 elif test -f "${new_path}.cmd"; then
16860 input_to_shortpath="${new_path}.cmd"
16861 else
16862 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16863 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16864 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16865 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16866 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16867 fi
16868 else
16869 input_to_shortpath="$new_path"
16870 fi
16871
16872 # Call helper function which possibly converts this using DOS-style short mode.
16873 # If so, the updated path is stored in $new_path.
16874 new_path="$input_to_shortpath"
16875
16876 input_path="$input_to_shortpath"
16877 # Check if we need to convert this using DOS-style short mode. If the path
16878 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16879 # take no chances and rewrite it.
16880 # Note: m4 eats our [], so we need to use [ and ] instead.
16881 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16882 if test "x$has_forbidden_chars" != x; then
16883 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16884 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16885 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16886 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16887 # Going to short mode and back again did indeed matter. Since short mode is
16888 # case insensitive, let's make it lowercase to improve readability.
16889 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16890 # Now convert it back to Unix-style (cygpath)
16891 input_path=`$CYGPATH -u "$shortmode_path"`
16892 new_path="$input_path"
16893 fi
16894 fi
16895
16896 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16897 if test "x$test_cygdrive_prefix" = x; then
16898 # As a simple fix, exclude /usr/bin since it's not a real path.
16899 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16900 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16901 # a path prefixed by /cygdrive for fixpath to work.
16902 new_path="$CYGWIN_ROOT_PATH$input_path"
16903 fi
16904 fi
16905
16906 # remove trailing .exe if any
16907 new_path="${new_path/%.exe/}"
16908
16909 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16910
16911 # First separate the path from the arguments. This will split at the first
16912 # space.
16913 complete="$FOUND_MAKE"
16914 path="${complete%% *}"
16915 tmp="$complete EOL"
16916 arguments="${tmp#* }"
16917
16918 # Input might be given as Windows format, start by converting to
16919 # unix format.
16920 new_path="$path"
16921
16922 windows_path="$new_path"
16923 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16924 unix_path=`$CYGPATH -u "$windows_path"`
16925 new_path="$unix_path"
16926 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16927 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16928 new_path="$unix_path"
16929 fi
16930
16931
16932 # Now try to locate executable using which
16933 new_path=`$WHICH "$new_path" 2> /dev/null`
16934
16935 if test "x$new_path" = x; then
16936 # Oops. Which didn't find the executable.
16937 # The splitting of arguments from the executable at a space might have been incorrect,
16938 # since paths with space are more likely in Windows. Give it another try with the whole
16939 # argument.
16940 path="$complete"
16941 arguments="EOL"
16942 new_path="$path"
16943
16944 windows_path="$new_path"
16945 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16946 unix_path=`$CYGPATH -u "$windows_path"`
16947 new_path="$unix_path"
16948 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16949 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16950 new_path="$unix_path"
16951 fi
16952
16953
16954 new_path=`$WHICH "$new_path" 2> /dev/null`
16955 # bat and cmd files are not always considered executable in MSYS causing which
16956 # to not find them
16957 if test "x$new_path" = x \
16958 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16959 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16960 new_path="$path"
16961
16962 windows_path="$new_path"
16963 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16964 unix_path=`$CYGPATH -u "$windows_path"`
16965 new_path="$unix_path"
16966 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16967 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16968 new_path="$unix_path"
16969 fi
16970
16971 fi
16972
16973 if test "x$new_path" = x; then
16974 # It's still not found. Now this is an unrecoverable error.
16975 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16976 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16977 has_space=`$ECHO "$complete" | $GREP " "`
16978 if test "x$has_space" != x; then
16979 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16980 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16981 fi
16982 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16983 fi
16984 fi
16985
16986 # Now new_path has a complete unix path to the binary
16987 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16988 # Keep paths in /bin as-is, but remove trailing .exe if any
16989 new_path="${new_path/%.exe/}"
16990 # Do not save /bin paths to all_fixpath_prefixes!
16991 else
16992 # Not in mixed or Windows style, start by that.
16993 new_path=`cmd //c echo $new_path`
16994
16995 input_path="$new_path"
16996 # Check if we need to convert this using DOS-style short mode. If the path
16997 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16998 # take no chances and rewrite it.
16999 # Note: m4 eats our [], so we need to use [ and ] instead.
17000 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17001 if test "x$has_forbidden_chars" != x; then
17002 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17003 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17004 fi
17005
17006 # Output is in $new_path
17007
17008 windows_path="$new_path"
17009 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17010 unix_path=`$CYGPATH -u "$windows_path"`
17011 new_path="$unix_path"
17012 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17013 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17014 new_path="$unix_path"
17015 fi
17016
17017 # remove trailing .exe if any
17018 new_path="${new_path/%.exe/}"
17019
17020 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17021 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17022 fi
17023
17024 else
17025 # We're on a unix platform. Hooray! :)
17026 # First separate the path from the arguments. This will split at the first
17027 # space.
17028 complete="$FOUND_MAKE"
17029 path="${complete%% *}"
17030 tmp="$complete EOL"
17031 arguments="${tmp#* }"
17032
17033 # Cannot rely on the command "which" here since it doesn't always work.
17034 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17035 if test -z "$is_absolute_path"; then
17036 # Path to executable is not absolute. Find it.
17037 IFS_save="$IFS"
17038 IFS=:
17039 for p in $PATH; do
17040 if test -f "$p/$path" && test -x "$p/$path"; then
17041 new_path="$p/$path"
17042 break
17043 fi
17044 done
17045 IFS="$IFS_save"
17046 else
17047 # This is an absolute path, we can use it without further modifications.
17048 new_path="$path"
17049 fi
17050
17051 if test "x$new_path" = x; then
17052 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17053 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17054 has_space=`$ECHO "$complete" | $GREP " "`
17055 if test "x$has_space" != x; then
17056 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17057 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17058 fi
17059 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17060 fi
17061 fi
17062
17063 # Now join together the path and the arguments once again
17064 if test "x$arguments" != xEOL; then
17065 new_complete="$new_path ${arguments% *}"
17066 else
17067 new_complete="$new_path"
17068 fi
17069
17070 if test "x$complete" != "x$new_complete"; then
17071 FOUND_MAKE="$new_complete"
17072 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17073 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17074 fi
17075 fi
17076
17077 fi
17078 fi
17079 fi
17080 fi
17081
17082 if test "x$FOUND_MAKE" = x; then
17083 for ac_prog in make
17084 do
17085 # Extract the first word of "$ac_prog", so it can be a program name with args.
17086 set dummy $ac_prog; ac_word=$2
17087 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17088 $as_echo_n "checking for $ac_word... " >&6; }
17089 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
17090 $as_echo_n "(cached) " >&6
17091 else
17092 case $CHECK_TOOLSDIR_MAKE in
17093 [\\/]* | ?:[\\/]*)
17094 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
17095 ;;
17096 *)
17097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17098 for as_dir in $PATH
17099 do
17100 IFS=$as_save_IFS
17101 test -z "$as_dir" && as_dir=.
17102 for ac_exec_ext in '' $ac_executable_extensions; do
17103 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17104 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
17105 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17106 break 2
17107 fi
17108 done
17109 done
17110 IFS=$as_save_IFS
17111
17112 ;;
17113 esac
17114 fi
17115 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
17116 if test -n "$CHECK_TOOLSDIR_MAKE"; then
17117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
17118 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
17119 else
17120 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17121 $as_echo "no" >&6; }
17122 fi
17123
17124
17125 test -n "$CHECK_TOOLSDIR_MAKE" && break
17126 done
17127
17128
17129 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
17130 DESCRIPTION="make in tools-dir"
17131
17132 # On Cygwin, we require a newer version of make than on other platforms
17133 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17134 MAKE_VERSION_EXPR="-e 4\."
17135 MAKE_REQUIRED_VERSION="4.0"
17136 else
17137 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17138 MAKE_REQUIRED_VERSION="3.81"
17139 fi
17140
17141 if test "x$MAKE_CANDIDATE" != x; then
17142 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17143 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17144 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17145 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17146 if test "x$IS_GNU_MAKE" = x; then
17147 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17148 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17149 else
17150 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17151 if test "x$IS_MODERN_MAKE" = x; then
17152 { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17153 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17154 else
17155 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17156 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17157 MAKE_EXPECTED_ENV='cygwin'
17158 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17159 MAKE_EXPECTED_ENV='msys'
17160 else
17161 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17162 fi
17163 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17164 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17165 else
17166 # Not relevant for non-Windows
17167 IS_MAKE_CORRECT_ENV=true
17168 fi
17169 if test "x$IS_MAKE_CORRECT_ENV" = x; then
17170 { $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
17171 $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;}
17172 else
17173 FOUND_MAKE=$MAKE_CANDIDATE
17174
17175 # Only process if variable expands to non-empty
17176
17177 if test "x$FOUND_MAKE" != x; then
17178 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17179
17180 # First separate the path from the arguments. This will split at the first
17181 # space.
17182 complete="$FOUND_MAKE"
17183 path="${complete%% *}"
17184 tmp="$complete EOL"
17185 arguments="${tmp#* }"
17186
17187 # Input might be given as Windows format, start by converting to
17188 # unix format.
17189 new_path=`$CYGPATH -u "$path"`
17190
17191 # Now try to locate executable using which
17192 new_path=`$WHICH "$new_path" 2> /dev/null`
17193 # bat and cmd files are not always considered executable in cygwin causing which
17194 # to not find them
17195 if test "x$new_path" = x \
17196 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17197 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17198 new_path=`$CYGPATH -u "$path"`
17199 fi
17200 if test "x$new_path" = x; then
17201 # Oops. Which didn't find the executable.
17202 # The splitting of arguments from the executable at a space might have been incorrect,
17203 # since paths with space are more likely in Windows. Give it another try with the whole
17204 # argument.
17205 path="$complete"
17206 arguments="EOL"
17207 new_path=`$CYGPATH -u "$path"`
17208 new_path=`$WHICH "$new_path" 2> /dev/null`
17209 # bat and cmd files are not always considered executable in cygwin causing which
17210 # to not find them
17211 if test "x$new_path" = x \
17212 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17213 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17214 new_path=`$CYGPATH -u "$path"`
17215 fi
17216 if test "x$new_path" = x; then
17217 # It's still not found. Now this is an unrecoverable error.
17218 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17219 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17220 has_space=`$ECHO "$complete" | $GREP " "`
17221 if test "x$has_space" != x; then
17222 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17223 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17224 fi
17225 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17226 fi
17227 fi
17228
17229 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17230 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17231 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17232 # "foo.exe" is OK but "foo" is an error.
17233 #
17234 # This test is therefore slightly more accurate than "test -f" to check for file presence.
17235 # It is also a way to make sure we got the proper file name for the real test later on.
17236 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17237 if test "x$test_shortpath" = x; then
17238 # Short path failed, file does not exist as specified.
17239 # Try adding .exe or .cmd
17240 if test -f "${new_path}.exe"; then
17241 input_to_shortpath="${new_path}.exe"
17242 elif test -f "${new_path}.cmd"; then
17243 input_to_shortpath="${new_path}.cmd"
17244 else
17245 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17246 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17247 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17248 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17249 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17250 fi
17251 else
17252 input_to_shortpath="$new_path"
17253 fi
17254
17255 # Call helper function which possibly converts this using DOS-style short mode.
17256 # If so, the updated path is stored in $new_path.
17257 new_path="$input_to_shortpath"
17258
17259 input_path="$input_to_shortpath"
17260 # Check if we need to convert this using DOS-style short mode. If the path
17261 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17262 # take no chances and rewrite it.
17263 # Note: m4 eats our [], so we need to use [ and ] instead.
17264 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17265 if test "x$has_forbidden_chars" != x; then
17266 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17267 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17268 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17269 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17270 # Going to short mode and back again did indeed matter. Since short mode is
17271 # case insensitive, let's make it lowercase to improve readability.
17272 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17273 # Now convert it back to Unix-style (cygpath)
17274 input_path=`$CYGPATH -u "$shortmode_path"`
17275 new_path="$input_path"
17276 fi
17277 fi
17278
17279 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17280 if test "x$test_cygdrive_prefix" = x; then
17281 # As a simple fix, exclude /usr/bin since it's not a real path.
17282 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17283 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17284 # a path prefixed by /cygdrive for fixpath to work.
17285 new_path="$CYGWIN_ROOT_PATH$input_path"
17286 fi
17287 fi
17288
17289 # remove trailing .exe if any
17290 new_path="${new_path/%.exe/}"
17291
17292 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17293
17294 # First separate the path from the arguments. This will split at the first
17295 # space.
17296 complete="$FOUND_MAKE"
17297 path="${complete%% *}"
17298 tmp="$complete EOL"
17299 arguments="${tmp#* }"
17300
17301 # Input might be given as Windows format, start by converting to
17302 # unix format.
17303 new_path="$path"
17304
17305 windows_path="$new_path"
17306 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17307 unix_path=`$CYGPATH -u "$windows_path"`
17308 new_path="$unix_path"
17309 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17310 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17311 new_path="$unix_path"
17312 fi
17313
17314
17315 # Now try to locate executable using which
17316 new_path=`$WHICH "$new_path" 2> /dev/null`
17317
17318 if test "x$new_path" = x; then
17319 # Oops. Which didn't find the executable.
17320 # The splitting of arguments from the executable at a space might have been incorrect,
17321 # since paths with space are more likely in Windows. Give it another try with the whole
17322 # argument.
17323 path="$complete"
17324 arguments="EOL"
17325 new_path="$path"
17326
17327 windows_path="$new_path"
17328 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17329 unix_path=`$CYGPATH -u "$windows_path"`
17330 new_path="$unix_path"
17331 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17332 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17333 new_path="$unix_path"
17334 fi
17335
17336
17337 new_path=`$WHICH "$new_path" 2> /dev/null`
17338 # bat and cmd files are not always considered executable in MSYS causing which
17339 # to not find them
17340 if test "x$new_path" = x \
17341 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17342 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17343 new_path="$path"
17344
17345 windows_path="$new_path"
17346 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17347 unix_path=`$CYGPATH -u "$windows_path"`
17348 new_path="$unix_path"
17349 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17350 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17351 new_path="$unix_path"
17352 fi
17353
17354 fi
17355
17356 if test "x$new_path" = x; then
17357 # It's still not found. Now this is an unrecoverable error.
17358 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17359 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17360 has_space=`$ECHO "$complete" | $GREP " "`
17361 if test "x$has_space" != x; then
17362 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17363 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17364 fi
17365 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17366 fi
17367 fi
17368
17369 # Now new_path has a complete unix path to the binary
17370 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17371 # Keep paths in /bin as-is, but remove trailing .exe if any
17372 new_path="${new_path/%.exe/}"
17373 # Do not save /bin paths to all_fixpath_prefixes!
17374 else
17375 # Not in mixed or Windows style, start by that.
17376 new_path=`cmd //c echo $new_path`
17377
17378 input_path="$new_path"
17379 # Check if we need to convert this using DOS-style short mode. If the path
17380 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17381 # take no chances and rewrite it.
17382 # Note: m4 eats our [], so we need to use [ and ] instead.
17383 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17384 if test "x$has_forbidden_chars" != x; then
17385 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17386 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17387 fi
17388
17389 # Output is in $new_path
17390
17391 windows_path="$new_path"
17392 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17393 unix_path=`$CYGPATH -u "$windows_path"`
17394 new_path="$unix_path"
17395 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17396 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17397 new_path="$unix_path"
17398 fi
17399
17400 # remove trailing .exe if any
17401 new_path="${new_path/%.exe/}"
17402
17403 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17404 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17405 fi
17406
17407 else
17408 # We're on a unix platform. Hooray! :)
17409 # First separate the path from the arguments. This will split at the first
17410 # space.
17411 complete="$FOUND_MAKE"
17412 path="${complete%% *}"
17413 tmp="$complete EOL"
17414 arguments="${tmp#* }"
17415
17416 # Cannot rely on the command "which" here since it doesn't always work.
17417 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17418 if test -z "$is_absolute_path"; then
17419 # Path to executable is not absolute. Find it.
17420 IFS_save="$IFS"
17421 IFS=:
17422 for p in $PATH; do
17423 if test -f "$p/$path" && test -x "$p/$path"; then
17424 new_path="$p/$path"
17425 break
17426 fi
17427 done
17428 IFS="$IFS_save"
17429 else
17430 # This is an absolute path, we can use it without further modifications.
17431 new_path="$path"
17432 fi
17433
17434 if test "x$new_path" = x; then
17435 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17436 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17437 has_space=`$ECHO "$complete" | $GREP " "`
17438 if test "x$has_space" != x; then
17439 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17440 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17441 fi
17442 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17443 fi
17444 fi
17445
17446 # Now join together the path and the arguments once again
17447 if test "x$arguments" != xEOL; then
17448 new_complete="$new_path ${arguments% *}"
17449 else
17450 new_complete="$new_path"
17451 fi
17452
17453 if test "x$complete" != "x$new_complete"; then
17454 FOUND_MAKE="$new_complete"
17455 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17456 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17457 fi
17458 fi
17459
17460 fi
17461 fi
17462 fi
17463 fi
17464
17465 fi
17466 PATH=$OLD_PATH
17467 fi
17468 fi
17469
17470 if test "x$FOUND_MAKE" = x; then
17471 as_fn_error $? "Cannot find GNU make $MAKE_REQUIRED_VERSION or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
17472 fi
17473 fi
17474
17475 MAKE=$FOUND_MAKE
17476
17477 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17478 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17479
17480
17481 # Check if make supports the output sync option and if so, setup using it.
17482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
17483 $as_echo_n "checking if make --output-sync is supported... " >&6; }
17484 if $MAKE --version -O > /dev/null 2>&1; then
17485 OUTPUT_SYNC_SUPPORTED=true
17486 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17487 $as_echo "yes" >&6; }
17488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
17489 $as_echo_n "checking for output-sync value... " >&6; }
17490
17491 # Check whether --with-output-sync was given.
17492 if test "${with_output_sync+set}" = set; then :
17493 withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
17494 fi
17495
17496 if test "x$OUTPUT_SYNC" = "x"; then
17497 OUTPUT_SYNC=none
17498 fi
17499 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
17500 $as_echo "$OUTPUT_SYNC" >&6; }
17501 if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
17502 as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
17503 fi
17504 else
17505 OUTPUT_SYNC_SUPPORTED=false
17506 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17507 $as_echo "no" >&6; }
17508 fi
17509
17510
17511
17512
17513
17514
17515 # Test if find supports -delete
17516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17517 $as_echo_n "checking if find supports -delete... " >&6; }
17518 FIND_DELETE="-delete"
17519
17520 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17521
17522 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17523
17524 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17525 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17526 # No, it does not.
17527 rm $DELETEDIR/TestIfFindSupportsDelete
17528 if test "x$OPENJDK_TARGET_OS" = "xaix"; then
17529 # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
17530 FIND_DELETE="-print | xargs rm"
17531 else
17532 FIND_DELETE="-exec rm \{\} \+"
17533 fi
17534 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17535 $as_echo "no" >&6; }
17536 else
17537 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17538 $as_echo "yes" >&6; }
17539 fi
17540 rmdir $DELETEDIR
17541
17542
17543
17544 # These tools might not be installed by default,
17545 # need hint on how to install them.
17546
17547
17548
17549 # Publish this variable in the help.
17550
17551
17552 if test "x$UNZIP" = x; then
17553 # The variable is not set by user, try to locate tool using the code snippet
17554 for ac_prog in unzip
17555 do
17556 # Extract the first word of "$ac_prog", so it can be a program name with args.
17557 set dummy $ac_prog; ac_word=$2
17558 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17559 $as_echo_n "checking for $ac_word... " >&6; }
17560 if ${ac_cv_path_UNZIP+:} false; then :
17561 $as_echo_n "(cached) " >&6
17562 else
17563 case $UNZIP in
17564 [\\/]* | ?:[\\/]*)
17565 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17566 ;;
17567 *)
17568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17569 for as_dir in $PATH
17570 do
17571 IFS=$as_save_IFS
17572 test -z "$as_dir" && as_dir=.
17573 for ac_exec_ext in '' $ac_executable_extensions; do
17574 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17575 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17576 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17577 break 2
17578 fi
17579 done
17580 done
17581 IFS=$as_save_IFS
17582
17583 ;;
17584 esac
17585 fi
17586 UNZIP=$ac_cv_path_UNZIP
17587 if test -n "$UNZIP"; then
17588 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17589 $as_echo "$UNZIP" >&6; }
17590 else
17591 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17592 $as_echo "no" >&6; }
17593 fi
17594
17595
17596 test -n "$UNZIP" && break
17597 done
17598
17599 else
17600 # The variable is set, but is it from the command line or the environment?
17601
17602 # Try to remove the string !UNZIP! from our list.
17603 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17604 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17605 # If it failed, the variable was not from the command line. Ignore it,
17606 # but warn the user (except for BASH, which is always set by the calling BASH).
17607 if test "xUNZIP" != xBASH; then
17608 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17609 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17610 fi
17611 # Try to locate tool using the code snippet
17612 for ac_prog in unzip
17613 do
17614 # Extract the first word of "$ac_prog", so it can be a program name with args.
17615 set dummy $ac_prog; ac_word=$2
17616 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17617 $as_echo_n "checking for $ac_word... " >&6; }
17618 if ${ac_cv_path_UNZIP+:} false; then :
17619 $as_echo_n "(cached) " >&6
17620 else
17621 case $UNZIP in
17622 [\\/]* | ?:[\\/]*)
17623 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17624 ;;
17625 *)
17626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17627 for as_dir in $PATH
17628 do
17629 IFS=$as_save_IFS
17630 test -z "$as_dir" && as_dir=.
17631 for ac_exec_ext in '' $ac_executable_extensions; do
17632 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17633 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17634 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17635 break 2
17636 fi
17637 done
17638 done
17639 IFS=$as_save_IFS
17640
17641 ;;
17642 esac
17643 fi
17644 UNZIP=$ac_cv_path_UNZIP
17645 if test -n "$UNZIP"; then
17646 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17647 $as_echo "$UNZIP" >&6; }
17648 else
17649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17650 $as_echo "no" >&6; }
17651 fi
17652
17653
17654 test -n "$UNZIP" && break
17655 done
17656
17657 else
17658 # If it succeeded, then it was overridden by the user. We will use it
17659 # for the tool.
17660
17661 # First remove it from the list of overridden variables, so we can test
17662 # for unknown variables in the end.
17663 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17664
17665 # Check if the provided tool contains a complete path.
17666 tool_specified="$UNZIP"
17667 tool_basename="${tool_specified##*/}"
17668 if test "x$tool_basename" = "x$tool_specified"; then
17669 # A command without a complete path is provided, search $PATH.
17670 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17671 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17672 # Extract the first word of "$tool_basename", so it can be a program name with args.
17673 set dummy $tool_basename; ac_word=$2
17674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17675 $as_echo_n "checking for $ac_word... " >&6; }
17676 if ${ac_cv_path_UNZIP+:} false; then :
17677 $as_echo_n "(cached) " >&6
17678 else
17679 case $UNZIP in
17680 [\\/]* | ?:[\\/]*)
17681 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17682 ;;
17683 *)
17684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17685 for as_dir in $PATH
17686 do
17687 IFS=$as_save_IFS
17688 test -z "$as_dir" && as_dir=.
17689 for ac_exec_ext in '' $ac_executable_extensions; do
17690 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17691 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17692 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17693 break 2
17694 fi
17695 done
17696 done
17697 IFS=$as_save_IFS
17698
17699 ;;
17700 esac
17701 fi
17702 UNZIP=$ac_cv_path_UNZIP
17703 if test -n "$UNZIP"; then
17704 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17705 $as_echo "$UNZIP" >&6; }
17706 else
17707 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17708 $as_echo "no" >&6; }
17709 fi
17710
17711
17712 if test "x$UNZIP" = x; then
17713 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17714 fi
17715 else
17716 # Otherwise we believe it is a complete path. Use it as it is.
17717 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17718 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17719 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17720 $as_echo_n "checking for UNZIP... " >&6; }
17721 if test ! -x "$tool_specified"; then
17722 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17723 $as_echo "not found" >&6; }
17724 as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17725 fi
17726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17727 $as_echo "$tool_specified" >&6; }
17728 fi
17729 fi
17730 fi
17731
17732
17733
17734 if test "x$UNZIP" = x; then
17735 as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17736 fi
17737
17738
17739
17740
17741
17742 # Publish this variable in the help.
17743
17744
17745 if test "x$ZIP" = x; then
17746 # The variable is not set by user, try to locate tool using the code snippet
17747 for ac_prog in zip
17748 do
17749 # Extract the first word of "$ac_prog", so it can be a program name with args.
17750 set dummy $ac_prog; ac_word=$2
17751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17752 $as_echo_n "checking for $ac_word... " >&6; }
17753 if ${ac_cv_path_ZIP+:} false; then :
17754 $as_echo_n "(cached) " >&6
17755 else
17756 case $ZIP in
17757 [\\/]* | ?:[\\/]*)
17758 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17759 ;;
17760 *)
17761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17762 for as_dir in $PATH
17763 do
17764 IFS=$as_save_IFS
17765 test -z "$as_dir" && as_dir=.
17766 for ac_exec_ext in '' $ac_executable_extensions; do
17767 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17768 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17769 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17770 break 2
17771 fi
17772 done
17773 done
17774 IFS=$as_save_IFS
17775
17776 ;;
17777 esac
17778 fi
17779 ZIP=$ac_cv_path_ZIP
17780 if test -n "$ZIP"; then
17781 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17782 $as_echo "$ZIP" >&6; }
17783 else
17784 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17785 $as_echo "no" >&6; }
17786 fi
17787
17788
17789 test -n "$ZIP" && break
17790 done
17791
17792 else
17793 # The variable is set, but is it from the command line or the environment?
17794
17795 # Try to remove the string !ZIP! from our list.
17796 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17797 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17798 # If it failed, the variable was not from the command line. Ignore it,
17799 # but warn the user (except for BASH, which is always set by the calling BASH).
17800 if test "xZIP" != xBASH; then
17801 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17802 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17803 fi
17804 # Try to locate tool using the code snippet
17805 for ac_prog in zip
17806 do
17807 # Extract the first word of "$ac_prog", so it can be a program name with args.
17808 set dummy $ac_prog; ac_word=$2
17809 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17810 $as_echo_n "checking for $ac_word... " >&6; }
17811 if ${ac_cv_path_ZIP+:} false; then :
17812 $as_echo_n "(cached) " >&6
17813 else
17814 case $ZIP in
17815 [\\/]* | ?:[\\/]*)
17816 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17817 ;;
17818 *)
17819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17820 for as_dir in $PATH
17821 do
17822 IFS=$as_save_IFS
17823 test -z "$as_dir" && as_dir=.
17824 for ac_exec_ext in '' $ac_executable_extensions; do
17825 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17826 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17827 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17828 break 2
17829 fi
17830 done
17831 done
17832 IFS=$as_save_IFS
17833
17834 ;;
17835 esac
17836 fi
17837 ZIP=$ac_cv_path_ZIP
17838 if test -n "$ZIP"; then
17839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17840 $as_echo "$ZIP" >&6; }
17841 else
17842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17843 $as_echo "no" >&6; }
17844 fi
17845
17846
17847 test -n "$ZIP" && break
17848 done
17849
17850 else
17851 # If it succeeded, then it was overridden by the user. We will use it
17852 # for the tool.
17853
17854 # First remove it from the list of overridden variables, so we can test
17855 # for unknown variables in the end.
17856 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17857
17858 # Check if the provided tool contains a complete path.
17859 tool_specified="$ZIP"
17860 tool_basename="${tool_specified##*/}"
17861 if test "x$tool_basename" = "x$tool_specified"; then
17862 # A command without a complete path is provided, search $PATH.
17863 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17864 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17865 # Extract the first word of "$tool_basename", so it can be a program name with args.
17866 set dummy $tool_basename; ac_word=$2
17867 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17868 $as_echo_n "checking for $ac_word... " >&6; }
17869 if ${ac_cv_path_ZIP+:} false; then :
17870 $as_echo_n "(cached) " >&6
17871 else
17872 case $ZIP in
17873 [\\/]* | ?:[\\/]*)
17874 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17875 ;;
17876 *)
17877 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17878 for as_dir in $PATH
17879 do
17880 IFS=$as_save_IFS
17881 test -z "$as_dir" && as_dir=.
17882 for ac_exec_ext in '' $ac_executable_extensions; do
17883 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17884 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17885 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17886 break 2
17887 fi
17888 done
17889 done
17890 IFS=$as_save_IFS
17891
17892 ;;
17893 esac
17894 fi
17895 ZIP=$ac_cv_path_ZIP
17896 if test -n "$ZIP"; then
17897 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17898 $as_echo "$ZIP" >&6; }
17899 else
17900 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17901 $as_echo "no" >&6; }
17902 fi
17903
17904
17905 if test "x$ZIP" = x; then
17906 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17907 fi
17908 else
17909 # Otherwise we believe it is a complete path. Use it as it is.
17910 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17911 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17913 $as_echo_n "checking for ZIP... " >&6; }
17914 if test ! -x "$tool_specified"; then
17915 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17916 $as_echo "not found" >&6; }
17917 as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17918 fi
17919 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17920 $as_echo "$tool_specified" >&6; }
17921 fi
17922 fi
17923 fi
17924
17925
17926
17927 if test "x$ZIP" = x; then
17928 as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17929 fi
17930
17931
17932
17933 # Non-required basic tools
17934
17935
17936
17937 # Publish this variable in the help.
17938
17939
17940 if test "x$LDD" = x; then
17941 # The variable is not set by user, try to locate tool using the code snippet
17942 for ac_prog in ldd
17943 do
17944 # Extract the first word of "$ac_prog", so it can be a program name with args.
17945 set dummy $ac_prog; ac_word=$2
17946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17947 $as_echo_n "checking for $ac_word... " >&6; }
17948 if ${ac_cv_path_LDD+:} false; then :
17949 $as_echo_n "(cached) " >&6
17950 else
17951 case $LDD in
17952 [\\/]* | ?:[\\/]*)
17953 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17954 ;;
17955 *)
17956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17957 for as_dir in $PATH
17958 do
17959 IFS=$as_save_IFS
17960 test -z "$as_dir" && as_dir=.
17961 for ac_exec_ext in '' $ac_executable_extensions; do
17962 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17963 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17964 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17965 break 2
17966 fi
17967 done
17968 done
17969 IFS=$as_save_IFS
17970
17971 ;;
17972 esac
17973 fi
17974 LDD=$ac_cv_path_LDD
17975 if test -n "$LDD"; then
17976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17977 $as_echo "$LDD" >&6; }
17978 else
17979 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17980 $as_echo "no" >&6; }
17981 fi
17982
17983
17984 test -n "$LDD" && break
17985 done
17986
17987 else
17988 # The variable is set, but is it from the command line or the environment?
17989
17990 # Try to remove the string !LDD! from our list.
17991 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17992 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17993 # If it failed, the variable was not from the command line. Ignore it,
17994 # but warn the user (except for BASH, which is always set by the calling BASH).
17995 if test "xLDD" != xBASH; then
17996 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17997 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17998 fi
17999 # Try to locate tool using the code snippet
18000 for ac_prog in ldd
18001 do
18002 # Extract the first word of "$ac_prog", so it can be a program name with args.
18003 set dummy $ac_prog; ac_word=$2
18004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18005 $as_echo_n "checking for $ac_word... " >&6; }
18006 if ${ac_cv_path_LDD+:} false; then :
18007 $as_echo_n "(cached) " >&6
18008 else
18009 case $LDD in
18010 [\\/]* | ?:[\\/]*)
18011 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
18012 ;;
18013 *)
18014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18015 for as_dir in $PATH
18016 do
18017 IFS=$as_save_IFS
18018 test -z "$as_dir" && as_dir=.
18019 for ac_exec_ext in '' $ac_executable_extensions; do
18020 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18021 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
18022 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18023 break 2
18024 fi
18025 done
18026 done
18027 IFS=$as_save_IFS
18028
18029 ;;
18030 esac
18031 fi
18032 LDD=$ac_cv_path_LDD
18033 if test -n "$LDD"; then
18034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
18035 $as_echo "$LDD" >&6; }
18036 else
18037 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18038 $as_echo "no" >&6; }
18039 fi
18040
18041
18042 test -n "$LDD" && break
18043 done
18044
18045 else
18046 # If it succeeded, then it was overridden by the user. We will use it
18047 # for the tool.
18048
18049 # First remove it from the list of overridden variables, so we can test
18050 # for unknown variables in the end.
18051 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18052
18053 # Check if the provided tool contains a complete path.
18054 tool_specified="$LDD"
18055 tool_basename="${tool_specified##*/}"
18056 if test "x$tool_basename" = "x$tool_specified"; then
18057 # A command without a complete path is provided, search $PATH.
18058 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
18059 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
18060 # Extract the first word of "$tool_basename", so it can be a program name with args.
18061 set dummy $tool_basename; ac_word=$2
18062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18063 $as_echo_n "checking for $ac_word... " >&6; }
18064 if ${ac_cv_path_LDD+:} false; then :
18065 $as_echo_n "(cached) " >&6
18066 else
18067 case $LDD in
18068 [\\/]* | ?:[\\/]*)
18069 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
18070 ;;
18071 *)
18072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18073 for as_dir in $PATH
18074 do
18075 IFS=$as_save_IFS
18076 test -z "$as_dir" && as_dir=.
18077 for ac_exec_ext in '' $ac_executable_extensions; do
18078 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18079 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
18080 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18081 break 2
18082 fi
18083 done
18084 done
18085 IFS=$as_save_IFS
18086
18087 ;;
18088 esac
18089 fi
18090 LDD=$ac_cv_path_LDD
18091 if test -n "$LDD"; then
18092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
18093 $as_echo "$LDD" >&6; }
18094 else
18095 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18096 $as_echo "no" >&6; }
18097 fi
18098
18099
18100 if test "x$LDD" = x; then
18101 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18102 fi
18103 else
18104 # Otherwise we believe it is a complete path. Use it as it is.
18105 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
18106 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
18107 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
18108 $as_echo_n "checking for LDD... " >&6; }
18109 if test ! -x "$tool_specified"; then
18110 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18111 $as_echo "not found" >&6; }
18112 as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
18113 fi
18114 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18115 $as_echo "$tool_specified" >&6; }
18116 fi
18117 fi
18118 fi
18119
18120
18121 if test "x$LDD" = "x"; then
18122 # List shared lib dependencies is used for
18123 # debug output and checking for forbidden dependencies.
18124 # We can build without it.
18125 LDD="true"
18126 fi
18127
18128
18129 # Publish this variable in the help.
18130
18131
18132 if test "x$OTOOL" = x; then
18133 # The variable is not set by user, try to locate tool using the code snippet
18134 for ac_prog in otool
18135 do
18136 # Extract the first word of "$ac_prog", so it can be a program name with args.
18137 set dummy $ac_prog; ac_word=$2
18138 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18139 $as_echo_n "checking for $ac_word... " >&6; }
18140 if ${ac_cv_path_OTOOL+:} false; then :
18141 $as_echo_n "(cached) " >&6
18142 else
18143 case $OTOOL in
18144 [\\/]* | ?:[\\/]*)
18145 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18146 ;;
18147 *)
18148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18149 for as_dir in $PATH
18150 do
18151 IFS=$as_save_IFS
18152 test -z "$as_dir" && as_dir=.
18153 for ac_exec_ext in '' $ac_executable_extensions; do
18154 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18155 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18156 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18157 break 2
18158 fi
18159 done
18160 done
18161 IFS=$as_save_IFS
18162
18163 ;;
18164 esac
18165 fi
18166 OTOOL=$ac_cv_path_OTOOL
18167 if test -n "$OTOOL"; then
18168 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18169 $as_echo "$OTOOL" >&6; }
18170 else
18171 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18172 $as_echo "no" >&6; }
18173 fi
18174
18175
18176 test -n "$OTOOL" && break
18177 done
18178
18179 else
18180 # The variable is set, but is it from the command line or the environment?
18181
18182 # Try to remove the string !OTOOL! from our list.
18183 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
18184 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18185 # If it failed, the variable was not from the command line. Ignore it,
18186 # but warn the user (except for BASH, which is always set by the calling BASH).
18187 if test "xOTOOL" != xBASH; then
18188 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
18189 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
18190 fi
18191 # Try to locate tool using the code snippet
18192 for ac_prog in otool
18193 do
18194 # Extract the first word of "$ac_prog", so it can be a program name with args.
18195 set dummy $ac_prog; ac_word=$2
18196 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18197 $as_echo_n "checking for $ac_word... " >&6; }
18198 if ${ac_cv_path_OTOOL+:} false; then :
18199 $as_echo_n "(cached) " >&6
18200 else
18201 case $OTOOL in
18202 [\\/]* | ?:[\\/]*)
18203 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18204 ;;
18205 *)
18206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18207 for as_dir in $PATH
18208 do
18209 IFS=$as_save_IFS
18210 test -z "$as_dir" && as_dir=.
18211 for ac_exec_ext in '' $ac_executable_extensions; do
18212 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18213 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18214 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18215 break 2
18216 fi
18217 done
18218 done
18219 IFS=$as_save_IFS
18220
18221 ;;
18222 esac
18223 fi
18224 OTOOL=$ac_cv_path_OTOOL
18225 if test -n "$OTOOL"; then
18226 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18227 $as_echo "$OTOOL" >&6; }
18228 else
18229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18230 $as_echo "no" >&6; }
18231 fi
18232
18233
18234 test -n "$OTOOL" && break
18235 done
18236
18237 else
18238 # If it succeeded, then it was overridden by the user. We will use it
18239 # for the tool.
18240
18241 # First remove it from the list of overridden variables, so we can test
18242 # for unknown variables in the end.
18243 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18244
18245 # Check if the provided tool contains a complete path.
18246 tool_specified="$OTOOL"
18247 tool_basename="${tool_specified##*/}"
18248 if test "x$tool_basename" = "x$tool_specified"; then
18249 # A command without a complete path is provided, search $PATH.
18250 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
18251 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
18252 # Extract the first word of "$tool_basename", so it can be a program name with args.
18253 set dummy $tool_basename; ac_word=$2
18254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18255 $as_echo_n "checking for $ac_word... " >&6; }
18256 if ${ac_cv_path_OTOOL+:} false; then :
18257 $as_echo_n "(cached) " >&6
18258 else
18259 case $OTOOL in
18260 [\\/]* | ?:[\\/]*)
18261 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18262 ;;
18263 *)
18264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18265 for as_dir in $PATH
18266 do
18267 IFS=$as_save_IFS
18268 test -z "$as_dir" && as_dir=.
18269 for ac_exec_ext in '' $ac_executable_extensions; do
18270 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18271 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18272 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18273 break 2
18274 fi
18275 done
18276 done
18277 IFS=$as_save_IFS
18278
18279 ;;
18280 esac
18281 fi
18282 OTOOL=$ac_cv_path_OTOOL
18283 if test -n "$OTOOL"; then
18284 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18285 $as_echo "$OTOOL" >&6; }
18286 else
18287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18288 $as_echo "no" >&6; }
18289 fi
18290
18291
18292 if test "x$OTOOL" = x; then
18293 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18294 fi
18295 else
18296 # Otherwise we believe it is a complete path. Use it as it is.
18297 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
18298 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
18299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
18300 $as_echo_n "checking for OTOOL... " >&6; }
18301 if test ! -x "$tool_specified"; then
18302 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18303 $as_echo "not found" >&6; }
18304 as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
18305 fi
18306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18307 $as_echo "$tool_specified" >&6; }
18308 fi
18309 fi
18310 fi
18311
18312
18313 if test "x$OTOOL" = "x"; then
18314 OTOOL="true"
18315 fi
18316
18317
18318 # Publish this variable in the help.
18319
18320
18321 if test "x$READELF" = x; then
18322 # The variable is not set by user, try to locate tool using the code snippet
18323 for ac_prog in greadelf readelf
18324 do
18325 # Extract the first word of "$ac_prog", so it can be a program name with args.
18326 set dummy $ac_prog; ac_word=$2
18327 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18328 $as_echo_n "checking for $ac_word... " >&6; }
18329 if ${ac_cv_path_READELF+:} false; then :
18330 $as_echo_n "(cached) " >&6
18331 else
18332 case $READELF in
18333 [\\/]* | ?:[\\/]*)
18334 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18335 ;;
18336 *)
18337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18338 for as_dir in $PATH
18339 do
18340 IFS=$as_save_IFS
18341 test -z "$as_dir" && as_dir=.
18342 for ac_exec_ext in '' $ac_executable_extensions; do
18343 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18344 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18345 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18346 break 2
18347 fi
18348 done
18349 done
18350 IFS=$as_save_IFS
18351
18352 ;;
18353 esac
18354 fi
18355 READELF=$ac_cv_path_READELF
18356 if test -n "$READELF"; then
18357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18358 $as_echo "$READELF" >&6; }
18359 else
18360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18361 $as_echo "no" >&6; }
18362 fi
18363
18364
18365 test -n "$READELF" && break
18366 done
18367
18368 else
18369 # The variable is set, but is it from the command line or the environment?
18370
18371 # Try to remove the string !READELF! from our list.
18372 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
18373 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18374 # If it failed, the variable was not from the command line. Ignore it,
18375 # but warn the user (except for BASH, which is always set by the calling BASH).
18376 if test "xREADELF" != xBASH; then
18377 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
18378 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
18379 fi
18380 # Try to locate tool using the code snippet
18381 for ac_prog in greadelf readelf
18382 do
18383 # Extract the first word of "$ac_prog", so it can be a program name with args.
18384 set dummy $ac_prog; ac_word=$2
18385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18386 $as_echo_n "checking for $ac_word... " >&6; }
18387 if ${ac_cv_path_READELF+:} false; then :
18388 $as_echo_n "(cached) " >&6
18389 else
18390 case $READELF in
18391 [\\/]* | ?:[\\/]*)
18392 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18393 ;;
18394 *)
18395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18396 for as_dir in $PATH
18397 do
18398 IFS=$as_save_IFS
18399 test -z "$as_dir" && as_dir=.
18400 for ac_exec_ext in '' $ac_executable_extensions; do
18401 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18402 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18403 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18404 break 2
18405 fi
18406 done
18407 done
18408 IFS=$as_save_IFS
18409
18410 ;;
18411 esac
18412 fi
18413 READELF=$ac_cv_path_READELF
18414 if test -n "$READELF"; then
18415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18416 $as_echo "$READELF" >&6; }
18417 else
18418 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18419 $as_echo "no" >&6; }
18420 fi
18421
18422
18423 test -n "$READELF" && break
18424 done
18425
18426 else
18427 # If it succeeded, then it was overridden by the user. We will use it
18428 # for the tool.
18429
18430 # First remove it from the list of overridden variables, so we can test
18431 # for unknown variables in the end.
18432 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18433
18434 # Check if the provided tool contains a complete path.
18435 tool_specified="$READELF"
18436 tool_basename="${tool_specified##*/}"
18437 if test "x$tool_basename" = "x$tool_specified"; then
18438 # A command without a complete path is provided, search $PATH.
18439 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
18440 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
18441 # Extract the first word of "$tool_basename", so it can be a program name with args.
18442 set dummy $tool_basename; ac_word=$2
18443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18444 $as_echo_n "checking for $ac_word... " >&6; }
18445 if ${ac_cv_path_READELF+:} false; then :
18446 $as_echo_n "(cached) " >&6
18447 else
18448 case $READELF in
18449 [\\/]* | ?:[\\/]*)
18450 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18451 ;;
18452 *)
18453 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18454 for as_dir in $PATH
18455 do
18456 IFS=$as_save_IFS
18457 test -z "$as_dir" && as_dir=.
18458 for ac_exec_ext in '' $ac_executable_extensions; do
18459 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18460 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18461 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18462 break 2
18463 fi
18464 done
18465 done
18466 IFS=$as_save_IFS
18467
18468 ;;
18469 esac
18470 fi
18471 READELF=$ac_cv_path_READELF
18472 if test -n "$READELF"; then
18473 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18474 $as_echo "$READELF" >&6; }
18475 else
18476 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18477 $as_echo "no" >&6; }
18478 fi
18479
18480
18481 if test "x$READELF" = x; then
18482 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18483 fi
18484 else
18485 # Otherwise we believe it is a complete path. Use it as it is.
18486 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18487 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18489 $as_echo_n "checking for READELF... " >&6; }
18490 if test ! -x "$tool_specified"; then
18491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18492 $as_echo "not found" >&6; }
18493 as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18494 fi
18495 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18496 $as_echo "$tool_specified" >&6; }
18497 fi
18498 fi
18499 fi
18500
18501
18502
18503
18504 # Publish this variable in the help.
18505
18506
18507 if test "x$HG" = x; then
18508 # The variable is not set by user, try to locate tool using the code snippet
18509 for ac_prog in hg
18510 do
18511 # Extract the first word of "$ac_prog", so it can be a program name with args.
18512 set dummy $ac_prog; ac_word=$2
18513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18514 $as_echo_n "checking for $ac_word... " >&6; }
18515 if ${ac_cv_path_HG+:} false; then :
18516 $as_echo_n "(cached) " >&6
18517 else
18518 case $HG in
18519 [\\/]* | ?:[\\/]*)
18520 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18521 ;;
18522 *)
18523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18524 for as_dir in $PATH
18525 do
18526 IFS=$as_save_IFS
18527 test -z "$as_dir" && as_dir=.
18528 for ac_exec_ext in '' $ac_executable_extensions; do
18529 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18530 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18531 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18532 break 2
18533 fi
18534 done
18535 done
18536 IFS=$as_save_IFS
18537
18538 ;;
18539 esac
18540 fi
18541 HG=$ac_cv_path_HG
18542 if test -n "$HG"; then
18543 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18544 $as_echo "$HG" >&6; }
18545 else
18546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18547 $as_echo "no" >&6; }
18548 fi
18549
18550
18551 test -n "$HG" && break
18552 done
18553
18554 else
18555 # The variable is set, but is it from the command line or the environment?
18556
18557 # Try to remove the string !HG! from our list.
18558 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18559 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18560 # If it failed, the variable was not from the command line. Ignore it,
18561 # but warn the user (except for BASH, which is always set by the calling BASH).
18562 if test "xHG" != xBASH; then
18563 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18564 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18565 fi
18566 # Try to locate tool using the code snippet
18567 for ac_prog in hg
18568 do
18569 # Extract the first word of "$ac_prog", so it can be a program name with args.
18570 set dummy $ac_prog; ac_word=$2
18571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18572 $as_echo_n "checking for $ac_word... " >&6; }
18573 if ${ac_cv_path_HG+:} false; then :
18574 $as_echo_n "(cached) " >&6
18575 else
18576 case $HG in
18577 [\\/]* | ?:[\\/]*)
18578 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18579 ;;
18580 *)
18581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18582 for as_dir in $PATH
18583 do
18584 IFS=$as_save_IFS
18585 test -z "$as_dir" && as_dir=.
18586 for ac_exec_ext in '' $ac_executable_extensions; do
18587 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18588 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18589 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18590 break 2
18591 fi
18592 done
18593 done
18594 IFS=$as_save_IFS
18595
18596 ;;
18597 esac
18598 fi
18599 HG=$ac_cv_path_HG
18600 if test -n "$HG"; then
18601 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18602 $as_echo "$HG" >&6; }
18603 else
18604 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18605 $as_echo "no" >&6; }
18606 fi
18607
18608
18609 test -n "$HG" && break
18610 done
18611
18612 else
18613 # If it succeeded, then it was overridden by the user. We will use it
18614 # for the tool.
18615
18616 # First remove it from the list of overridden variables, so we can test
18617 # for unknown variables in the end.
18618 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18619
18620 # Check if the provided tool contains a complete path.
18621 tool_specified="$HG"
18622 tool_basename="${tool_specified##*/}"
18623 if test "x$tool_basename" = "x$tool_specified"; then
18624 # A command without a complete path is provided, search $PATH.
18625 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18626 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18627 # Extract the first word of "$tool_basename", so it can be a program name with args.
18628 set dummy $tool_basename; ac_word=$2
18629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18630 $as_echo_n "checking for $ac_word... " >&6; }
18631 if ${ac_cv_path_HG+:} false; then :
18632 $as_echo_n "(cached) " >&6
18633 else
18634 case $HG in
18635 [\\/]* | ?:[\\/]*)
18636 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18637 ;;
18638 *)
18639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18640 for as_dir in $PATH
18641 do
18642 IFS=$as_save_IFS
18643 test -z "$as_dir" && as_dir=.
18644 for ac_exec_ext in '' $ac_executable_extensions; do
18645 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18646 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18647 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18648 break 2
18649 fi
18650 done
18651 done
18652 IFS=$as_save_IFS
18653
18654 ;;
18655 esac
18656 fi
18657 HG=$ac_cv_path_HG
18658 if test -n "$HG"; then
18659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18660 $as_echo "$HG" >&6; }
18661 else
18662 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18663 $as_echo "no" >&6; }
18664 fi
18665
18666
18667 if test "x$HG" = x; then
18668 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18669 fi
18670 else
18671 # Otherwise we believe it is a complete path. Use it as it is.
18672 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18673 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18675 $as_echo_n "checking for HG... " >&6; }
18676 if test ! -x "$tool_specified"; then
18677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18678 $as_echo "not found" >&6; }
18679 as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18680 fi
18681 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18682 $as_echo "$tool_specified" >&6; }
18683 fi
18684 fi
18685 fi
18686
18687
18688
18689
18690 # Publish this variable in the help.
18691
18692
18693 if test "x$STAT" = x; then
18694 # The variable is not set by user, try to locate tool using the code snippet
18695 for ac_prog in stat
18696 do
18697 # Extract the first word of "$ac_prog", so it can be a program name with args.
18698 set dummy $ac_prog; ac_word=$2
18699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18700 $as_echo_n "checking for $ac_word... " >&6; }
18701 if ${ac_cv_path_STAT+:} false; then :
18702 $as_echo_n "(cached) " >&6
18703 else
18704 case $STAT in
18705 [\\/]* | ?:[\\/]*)
18706 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18707 ;;
18708 *)
18709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18710 for as_dir in $PATH
18711 do
18712 IFS=$as_save_IFS
18713 test -z "$as_dir" && as_dir=.
18714 for ac_exec_ext in '' $ac_executable_extensions; do
18715 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18716 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18717 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18718 break 2
18719 fi
18720 done
18721 done
18722 IFS=$as_save_IFS
18723
18724 ;;
18725 esac
18726 fi
18727 STAT=$ac_cv_path_STAT
18728 if test -n "$STAT"; then
18729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18730 $as_echo "$STAT" >&6; }
18731 else
18732 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18733 $as_echo "no" >&6; }
18734 fi
18735
18736
18737 test -n "$STAT" && break
18738 done
18739
18740 else
18741 # The variable is set, but is it from the command line or the environment?
18742
18743 # Try to remove the string !STAT! from our list.
18744 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18745 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18746 # If it failed, the variable was not from the command line. Ignore it,
18747 # but warn the user (except for BASH, which is always set by the calling BASH).
18748 if test "xSTAT" != xBASH; then
18749 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18750 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18751 fi
18752 # Try to locate tool using the code snippet
18753 for ac_prog in stat
18754 do
18755 # Extract the first word of "$ac_prog", so it can be a program name with args.
18756 set dummy $ac_prog; ac_word=$2
18757 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18758 $as_echo_n "checking for $ac_word... " >&6; }
18759 if ${ac_cv_path_STAT+:} false; then :
18760 $as_echo_n "(cached) " >&6
18761 else
18762 case $STAT in
18763 [\\/]* | ?:[\\/]*)
18764 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18765 ;;
18766 *)
18767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18768 for as_dir in $PATH
18769 do
18770 IFS=$as_save_IFS
18771 test -z "$as_dir" && as_dir=.
18772 for ac_exec_ext in '' $ac_executable_extensions; do
18773 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18774 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18775 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18776 break 2
18777 fi
18778 done
18779 done
18780 IFS=$as_save_IFS
18781
18782 ;;
18783 esac
18784 fi
18785 STAT=$ac_cv_path_STAT
18786 if test -n "$STAT"; then
18787 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18788 $as_echo "$STAT" >&6; }
18789 else
18790 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18791 $as_echo "no" >&6; }
18792 fi
18793
18794
18795 test -n "$STAT" && break
18796 done
18797
18798 else
18799 # If it succeeded, then it was overridden by the user. We will use it
18800 # for the tool.
18801
18802 # First remove it from the list of overridden variables, so we can test
18803 # for unknown variables in the end.
18804 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18805
18806 # Check if the provided tool contains a complete path.
18807 tool_specified="$STAT"
18808 tool_basename="${tool_specified##*/}"
18809 if test "x$tool_basename" = "x$tool_specified"; then
18810 # A command without a complete path is provided, search $PATH.
18811 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18812 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18813 # Extract the first word of "$tool_basename", so it can be a program name with args.
18814 set dummy $tool_basename; ac_word=$2
18815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18816 $as_echo_n "checking for $ac_word... " >&6; }
18817 if ${ac_cv_path_STAT+:} false; then :
18818 $as_echo_n "(cached) " >&6
18819 else
18820 case $STAT in
18821 [\\/]* | ?:[\\/]*)
18822 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18823 ;;
18824 *)
18825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18826 for as_dir in $PATH
18827 do
18828 IFS=$as_save_IFS
18829 test -z "$as_dir" && as_dir=.
18830 for ac_exec_ext in '' $ac_executable_extensions; do
18831 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18832 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18833 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18834 break 2
18835 fi
18836 done
18837 done
18838 IFS=$as_save_IFS
18839
18840 ;;
18841 esac
18842 fi
18843 STAT=$ac_cv_path_STAT
18844 if test -n "$STAT"; then
18845 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18846 $as_echo "$STAT" >&6; }
18847 else
18848 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18849 $as_echo "no" >&6; }
18850 fi
18851
18852
18853 if test "x$STAT" = x; then
18854 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18855 fi
18856 else
18857 # Otherwise we believe it is a complete path. Use it as it is.
18858 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18859 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18861 $as_echo_n "checking for STAT... " >&6; }
18862 if test ! -x "$tool_specified"; then
18863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18864 $as_echo "not found" >&6; }
18865 as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18866 fi
18867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18868 $as_echo "$tool_specified" >&6; }
18869 fi
18870 fi
18871 fi
18872
18873
18874
18875
18876 # Publish this variable in the help.
18877
18878
18879 if test "x$TIME" = x; then
18880 # The variable is not set by user, try to locate tool using the code snippet
18881 for ac_prog in time
18882 do
18883 # Extract the first word of "$ac_prog", so it can be a program name with args.
18884 set dummy $ac_prog; ac_word=$2
18885 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18886 $as_echo_n "checking for $ac_word... " >&6; }
18887 if ${ac_cv_path_TIME+:} false; then :
18888 $as_echo_n "(cached) " >&6
18889 else
18890 case $TIME in
18891 [\\/]* | ?:[\\/]*)
18892 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18893 ;;
18894 *)
18895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18896 for as_dir in $PATH
18897 do
18898 IFS=$as_save_IFS
18899 test -z "$as_dir" && as_dir=.
18900 for ac_exec_ext in '' $ac_executable_extensions; do
18901 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18902 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18903 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18904 break 2
18905 fi
18906 done
18907 done
18908 IFS=$as_save_IFS
18909
18910 ;;
18911 esac
18912 fi
18913 TIME=$ac_cv_path_TIME
18914 if test -n "$TIME"; then
18915 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18916 $as_echo "$TIME" >&6; }
18917 else
18918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18919 $as_echo "no" >&6; }
18920 fi
18921
18922
18923 test -n "$TIME" && break
18924 done
18925
18926 else
18927 # The variable is set, but is it from the command line or the environment?
18928
18929 # Try to remove the string !TIME! from our list.
18930 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18931 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18932 # If it failed, the variable was not from the command line. Ignore it,
18933 # but warn the user (except for BASH, which is always set by the calling BASH).
18934 if test "xTIME" != xBASH; then
18935 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18936 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18937 fi
18938 # Try to locate tool using the code snippet
18939 for ac_prog in time
18940 do
18941 # Extract the first word of "$ac_prog", so it can be a program name with args.
18942 set dummy $ac_prog; ac_word=$2
18943 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18944 $as_echo_n "checking for $ac_word... " >&6; }
18945 if ${ac_cv_path_TIME+:} false; then :
18946 $as_echo_n "(cached) " >&6
18947 else
18948 case $TIME in
18949 [\\/]* | ?:[\\/]*)
18950 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18951 ;;
18952 *)
18953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18954 for as_dir in $PATH
18955 do
18956 IFS=$as_save_IFS
18957 test -z "$as_dir" && as_dir=.
18958 for ac_exec_ext in '' $ac_executable_extensions; do
18959 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18960 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18961 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18962 break 2
18963 fi
18964 done
18965 done
18966 IFS=$as_save_IFS
18967
18968 ;;
18969 esac
18970 fi
18971 TIME=$ac_cv_path_TIME
18972 if test -n "$TIME"; then
18973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18974 $as_echo "$TIME" >&6; }
18975 else
18976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18977 $as_echo "no" >&6; }
18978 fi
18979
18980
18981 test -n "$TIME" && break
18982 done
18983
18984 else
18985 # If it succeeded, then it was overridden by the user. We will use it
18986 # for the tool.
18987
18988 # First remove it from the list of overridden variables, so we can test
18989 # for unknown variables in the end.
18990 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18991
18992 # Check if the provided tool contains a complete path.
18993 tool_specified="$TIME"
18994 tool_basename="${tool_specified##*/}"
18995 if test "x$tool_basename" = "x$tool_specified"; then
18996 # A command without a complete path is provided, search $PATH.
18997 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18998 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18999 # Extract the first word of "$tool_basename", so it can be a program name with args.
19000 set dummy $tool_basename; ac_word=$2
19001 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19002 $as_echo_n "checking for $ac_word... " >&6; }
19003 if ${ac_cv_path_TIME+:} false; then :
19004 $as_echo_n "(cached) " >&6
19005 else
19006 case $TIME in
19007 [\\/]* | ?:[\\/]*)
19008 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
19009 ;;
19010 *)
19011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19012 for as_dir in $PATH
19013 do
19014 IFS=$as_save_IFS
19015 test -z "$as_dir" && as_dir=.
19016 for ac_exec_ext in '' $ac_executable_extensions; do
19017 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19018 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
19019 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19020 break 2
19021 fi
19022 done
19023 done
19024 IFS=$as_save_IFS
19025
19026 ;;
19027 esac
19028 fi
19029 TIME=$ac_cv_path_TIME
19030 if test -n "$TIME"; then
19031 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
19032 $as_echo "$TIME" >&6; }
19033 else
19034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19035 $as_echo "no" >&6; }
19036 fi
19037
19038
19039 if test "x$TIME" = x; then
19040 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19041 fi
19042 else
19043 # Otherwise we believe it is a complete path. Use it as it is.
19044 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
19045 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
19046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
19047 $as_echo_n "checking for TIME... " >&6; }
19048 if test ! -x "$tool_specified"; then
19049 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19050 $as_echo "not found" >&6; }
19051 as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
19052 fi
19053 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19054 $as_echo "$tool_specified" >&6; }
19055 fi
19056 fi
19057 fi
19058
19059
19060 # Check if it's GNU time
19061 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
19062 if test "x$IS_GNU_TIME" != x; then
19063 IS_GNU_TIME=yes
19064 else
19065 IS_GNU_TIME=no
19066 fi
19067
19068
19069 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
19070
19071
19072
19073 # Publish this variable in the help.
19074
19075
19076 if test "x$DSYMUTIL" = x; then
19077 # The variable is not set by user, try to locate tool using the code snippet
19078 for ac_prog in dsymutil
19079 do
19080 # Extract the first word of "$ac_prog", so it can be a program name with args.
19081 set dummy $ac_prog; ac_word=$2
19082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19083 $as_echo_n "checking for $ac_word... " >&6; }
19084 if ${ac_cv_path_DSYMUTIL+:} false; then :
19085 $as_echo_n "(cached) " >&6
19086 else
19087 case $DSYMUTIL in
19088 [\\/]* | ?:[\\/]*)
19089 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19090 ;;
19091 *)
19092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19093 for as_dir in $PATH
19094 do
19095 IFS=$as_save_IFS
19096 test -z "$as_dir" && as_dir=.
19097 for ac_exec_ext in '' $ac_executable_extensions; do
19098 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19099 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19100 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19101 break 2
19102 fi
19103 done
19104 done
19105 IFS=$as_save_IFS
19106
19107 ;;
19108 esac
19109 fi
19110 DSYMUTIL=$ac_cv_path_DSYMUTIL
19111 if test -n "$DSYMUTIL"; then
19112 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19113 $as_echo "$DSYMUTIL" >&6; }
19114 else
19115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19116 $as_echo "no" >&6; }
19117 fi
19118
19119
19120 test -n "$DSYMUTIL" && break
19121 done
19122
19123 else
19124 # The variable is set, but is it from the command line or the environment?
19125
19126 # Try to remove the string !DSYMUTIL! from our list.
19127 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
19128 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19129 # If it failed, the variable was not from the command line. Ignore it,
19130 # but warn the user (except for BASH, which is always set by the calling BASH).
19131 if test "xDSYMUTIL" != xBASH; then
19132 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
19133 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
19134 fi
19135 # Try to locate tool using the code snippet
19136 for ac_prog in dsymutil
19137 do
19138 # Extract the first word of "$ac_prog", so it can be a program name with args.
19139 set dummy $ac_prog; ac_word=$2
19140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19141 $as_echo_n "checking for $ac_word... " >&6; }
19142 if ${ac_cv_path_DSYMUTIL+:} false; then :
19143 $as_echo_n "(cached) " >&6
19144 else
19145 case $DSYMUTIL in
19146 [\\/]* | ?:[\\/]*)
19147 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19148 ;;
19149 *)
19150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19151 for as_dir in $PATH
19152 do
19153 IFS=$as_save_IFS
19154 test -z "$as_dir" && as_dir=.
19155 for ac_exec_ext in '' $ac_executable_extensions; do
19156 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19157 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19158 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19159 break 2
19160 fi
19161 done
19162 done
19163 IFS=$as_save_IFS
19164
19165 ;;
19166 esac
19167 fi
19168 DSYMUTIL=$ac_cv_path_DSYMUTIL
19169 if test -n "$DSYMUTIL"; then
19170 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19171 $as_echo "$DSYMUTIL" >&6; }
19172 else
19173 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19174 $as_echo "no" >&6; }
19175 fi
19176
19177
19178 test -n "$DSYMUTIL" && break
19179 done
19180
19181 else
19182 # If it succeeded, then it was overridden by the user. We will use it
19183 # for the tool.
19184
19185 # First remove it from the list of overridden variables, so we can test
19186 # for unknown variables in the end.
19187 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19188
19189 # Check if the provided tool contains a complete path.
19190 tool_specified="$DSYMUTIL"
19191 tool_basename="${tool_specified##*/}"
19192 if test "x$tool_basename" = "x$tool_specified"; then
19193 # A command without a complete path is provided, search $PATH.
19194 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
19195 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
19196 # Extract the first word of "$tool_basename", so it can be a program name with args.
19197 set dummy $tool_basename; ac_word=$2
19198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19199 $as_echo_n "checking for $ac_word... " >&6; }
19200 if ${ac_cv_path_DSYMUTIL+:} false; then :
19201 $as_echo_n "(cached) " >&6
19202 else
19203 case $DSYMUTIL in
19204 [\\/]* | ?:[\\/]*)
19205 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19206 ;;
19207 *)
19208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19209 for as_dir in $PATH
19210 do
19211 IFS=$as_save_IFS
19212 test -z "$as_dir" && as_dir=.
19213 for ac_exec_ext in '' $ac_executable_extensions; do
19214 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19215 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19216 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19217 break 2
19218 fi
19219 done
19220 done
19221 IFS=$as_save_IFS
19222
19223 ;;
19224 esac
19225 fi
19226 DSYMUTIL=$ac_cv_path_DSYMUTIL
19227 if test -n "$DSYMUTIL"; then
19228 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19229 $as_echo "$DSYMUTIL" >&6; }
19230 else
19231 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19232 $as_echo "no" >&6; }
19233 fi
19234
19235
19236 if test "x$DSYMUTIL" = x; then
19237 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19238 fi
19239 else
19240 # Otherwise we believe it is a complete path. Use it as it is.
19241 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
19242 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
19243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
19244 $as_echo_n "checking for DSYMUTIL... " >&6; }
19245 if test ! -x "$tool_specified"; then
19246 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19247 $as_echo "not found" >&6; }
19248 as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
19249 fi
19250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19251 $as_echo "$tool_specified" >&6; }
19252 fi
19253 fi
19254 fi
19255
19256
19257
19258 if test "x$DSYMUTIL" = x; then
19259 as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
19260 fi
19261
19262
19263
19264
19265
19266 # Publish this variable in the help.
19267
19268
19269 if test "x$XATTR" = x; then
19270 # The variable is not set by user, try to locate tool using the code snippet
19271 for ac_prog in xattr
19272 do
19273 # Extract the first word of "$ac_prog", so it can be a program name with args.
19274 set dummy $ac_prog; ac_word=$2
19275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19276 $as_echo_n "checking for $ac_word... " >&6; }
19277 if ${ac_cv_path_XATTR+:} false; then :
19278 $as_echo_n "(cached) " >&6
19279 else
19280 case $XATTR in
19281 [\\/]* | ?:[\\/]*)
19282 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19283 ;;
19284 *)
19285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19286 for as_dir in $PATH
19287 do
19288 IFS=$as_save_IFS
19289 test -z "$as_dir" && as_dir=.
19290 for ac_exec_ext in '' $ac_executable_extensions; do
19291 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19292 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19293 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19294 break 2
19295 fi
19296 done
19297 done
19298 IFS=$as_save_IFS
19299
19300 ;;
19301 esac
19302 fi
19303 XATTR=$ac_cv_path_XATTR
19304 if test -n "$XATTR"; then
19305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19306 $as_echo "$XATTR" >&6; }
19307 else
19308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19309 $as_echo "no" >&6; }
19310 fi
19311
19312
19313 test -n "$XATTR" && break
19314 done
19315
19316 else
19317 # The variable is set, but is it from the command line or the environment?
19318
19319 # Try to remove the string !XATTR! from our list.
19320 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19321 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19322 # If it failed, the variable was not from the command line. Ignore it,
19323 # but warn the user (except for BASH, which is always set by the calling BASH).
19324 if test "xXATTR" != xBASH; then
19325 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19326 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19327 fi
19328 # Try to locate tool using the code snippet
19329 for ac_prog in xattr
19330 do
19331 # Extract the first word of "$ac_prog", so it can be a program name with args.
19332 set dummy $ac_prog; ac_word=$2
19333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19334 $as_echo_n "checking for $ac_word... " >&6; }
19335 if ${ac_cv_path_XATTR+:} false; then :
19336 $as_echo_n "(cached) " >&6
19337 else
19338 case $XATTR in
19339 [\\/]* | ?:[\\/]*)
19340 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19341 ;;
19342 *)
19343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19344 for as_dir in $PATH
19345 do
19346 IFS=$as_save_IFS
19347 test -z "$as_dir" && as_dir=.
19348 for ac_exec_ext in '' $ac_executable_extensions; do
19349 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19350 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19351 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19352 break 2
19353 fi
19354 done
19355 done
19356 IFS=$as_save_IFS
19357
19358 ;;
19359 esac
19360 fi
19361 XATTR=$ac_cv_path_XATTR
19362 if test -n "$XATTR"; then
19363 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19364 $as_echo "$XATTR" >&6; }
19365 else
19366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19367 $as_echo "no" >&6; }
19368 fi
19369
19370
19371 test -n "$XATTR" && break
19372 done
19373
19374 else
19375 # If it succeeded, then it was overridden by the user. We will use it
19376 # for the tool.
19377
19378 # First remove it from the list of overridden variables, so we can test
19379 # for unknown variables in the end.
19380 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19381
19382 # Check if the provided tool contains a complete path.
19383 tool_specified="$XATTR"
19384 tool_basename="${tool_specified##*/}"
19385 if test "x$tool_basename" = "x$tool_specified"; then
19386 # A command without a complete path is provided, search $PATH.
19387 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19388 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19389 # Extract the first word of "$tool_basename", so it can be a program name with args.
19390 set dummy $tool_basename; ac_word=$2
19391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19392 $as_echo_n "checking for $ac_word... " >&6; }
19393 if ${ac_cv_path_XATTR+:} false; then :
19394 $as_echo_n "(cached) " >&6
19395 else
19396 case $XATTR in
19397 [\\/]* | ?:[\\/]*)
19398 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19399 ;;
19400 *)
19401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19402 for as_dir in $PATH
19403 do
19404 IFS=$as_save_IFS
19405 test -z "$as_dir" && as_dir=.
19406 for ac_exec_ext in '' $ac_executable_extensions; do
19407 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19408 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19409 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19410 break 2
19411 fi
19412 done
19413 done
19414 IFS=$as_save_IFS
19415
19416 ;;
19417 esac
19418 fi
19419 XATTR=$ac_cv_path_XATTR
19420 if test -n "$XATTR"; then
19421 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19422 $as_echo "$XATTR" >&6; }
19423 else
19424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19425 $as_echo "no" >&6; }
19426 fi
19427
19428
19429 if test "x$XATTR" = x; then
19430 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19431 fi
19432 else
19433 # Otherwise we believe it is a complete path. Use it as it is.
19434 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19435 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19437 $as_echo_n "checking for XATTR... " >&6; }
19438 if test ! -x "$tool_specified"; then
19439 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19440 $as_echo "not found" >&6; }
19441 as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19442 fi
19443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19444 $as_echo "$tool_specified" >&6; }
19445 fi
19446 fi
19447 fi
19448
19449
19450
19451 if test "x$XATTR" = x; then
19452 as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19453 fi
19454
19455
19456
19457
19458 # Publish this variable in the help.
19459
19460
19461 if test "x$CODESIGN" = x; then
19462 # The variable is not set by user, try to locate tool using the code snippet
19463 for ac_prog in codesign
19464 do
19465 # Extract the first word of "$ac_prog", so it can be a program name with args.
19466 set dummy $ac_prog; ac_word=$2
19467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19468 $as_echo_n "checking for $ac_word... " >&6; }
19469 if ${ac_cv_path_CODESIGN+:} false; then :
19470 $as_echo_n "(cached) " >&6
19471 else
19472 case $CODESIGN in
19473 [\\/]* | ?:[\\/]*)
19474 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19475 ;;
19476 *)
19477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19478 for as_dir in $PATH
19479 do
19480 IFS=$as_save_IFS
19481 test -z "$as_dir" && as_dir=.
19482 for ac_exec_ext in '' $ac_executable_extensions; do
19483 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19484 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19485 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19486 break 2
19487 fi
19488 done
19489 done
19490 IFS=$as_save_IFS
19491
19492 ;;
19493 esac
19494 fi
19495 CODESIGN=$ac_cv_path_CODESIGN
19496 if test -n "$CODESIGN"; then
19497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19498 $as_echo "$CODESIGN" >&6; }
19499 else
19500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19501 $as_echo "no" >&6; }
19502 fi
19503
19504
19505 test -n "$CODESIGN" && break
19506 done
19507
19508 else
19509 # The variable is set, but is it from the command line or the environment?
19510
19511 # Try to remove the string !CODESIGN! from our list.
19512 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19513 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19514 # If it failed, the variable was not from the command line. Ignore it,
19515 # but warn the user (except for BASH, which is always set by the calling BASH).
19516 if test "xCODESIGN" != xBASH; then
19517 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19518 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19519 fi
19520 # Try to locate tool using the code snippet
19521 for ac_prog in codesign
19522 do
19523 # Extract the first word of "$ac_prog", so it can be a program name with args.
19524 set dummy $ac_prog; ac_word=$2
19525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19526 $as_echo_n "checking for $ac_word... " >&6; }
19527 if ${ac_cv_path_CODESIGN+:} false; then :
19528 $as_echo_n "(cached) " >&6
19529 else
19530 case $CODESIGN in
19531 [\\/]* | ?:[\\/]*)
19532 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19533 ;;
19534 *)
19535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19536 for as_dir in $PATH
19537 do
19538 IFS=$as_save_IFS
19539 test -z "$as_dir" && as_dir=.
19540 for ac_exec_ext in '' $ac_executable_extensions; do
19541 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19542 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19543 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19544 break 2
19545 fi
19546 done
19547 done
19548 IFS=$as_save_IFS
19549
19550 ;;
19551 esac
19552 fi
19553 CODESIGN=$ac_cv_path_CODESIGN
19554 if test -n "$CODESIGN"; then
19555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19556 $as_echo "$CODESIGN" >&6; }
19557 else
19558 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19559 $as_echo "no" >&6; }
19560 fi
19561
19562
19563 test -n "$CODESIGN" && break
19564 done
19565
19566 else
19567 # If it succeeded, then it was overridden by the user. We will use it
19568 # for the tool.
19569
19570 # First remove it from the list of overridden variables, so we can test
19571 # for unknown variables in the end.
19572 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19573
19574 # Check if the provided tool contains a complete path.
19575 tool_specified="$CODESIGN"
19576 tool_basename="${tool_specified##*/}"
19577 if test "x$tool_basename" = "x$tool_specified"; then
19578 # A command without a complete path is provided, search $PATH.
19579 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19580 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19581 # Extract the first word of "$tool_basename", so it can be a program name with args.
19582 set dummy $tool_basename; ac_word=$2
19583 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19584 $as_echo_n "checking for $ac_word... " >&6; }
19585 if ${ac_cv_path_CODESIGN+:} false; then :
19586 $as_echo_n "(cached) " >&6
19587 else
19588 case $CODESIGN in
19589 [\\/]* | ?:[\\/]*)
19590 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19591 ;;
19592 *)
19593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19594 for as_dir in $PATH
19595 do
19596 IFS=$as_save_IFS
19597 test -z "$as_dir" && as_dir=.
19598 for ac_exec_ext in '' $ac_executable_extensions; do
19599 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19600 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19601 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19602 break 2
19603 fi
19604 done
19605 done
19606 IFS=$as_save_IFS
19607
19608 ;;
19609 esac
19610 fi
19611 CODESIGN=$ac_cv_path_CODESIGN
19612 if test -n "$CODESIGN"; then
19613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19614 $as_echo "$CODESIGN" >&6; }
19615 else
19616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19617 $as_echo "no" >&6; }
19618 fi
19619
19620
19621 if test "x$CODESIGN" = x; then
19622 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19623 fi
19624 else
19625 # Otherwise we believe it is a complete path. Use it as it is.
19626 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19627 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19628 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19629 $as_echo_n "checking for CODESIGN... " >&6; }
19630 if test ! -x "$tool_specified"; then
19631 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19632 $as_echo "not found" >&6; }
19633 as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19634 fi
19635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19636 $as_echo "$tool_specified" >&6; }
19637 fi
19638 fi
19639 fi
19640
19641
19642 if test "x$CODESIGN" != "x"; then
19643 # Verify that the openjdk_codesign certificate is present
19644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19645 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19646 rm -f codesign-testfile
19647 touch codesign-testfile
19648 codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19649 rm -f codesign-testfile
19650 if test "x$CODESIGN" = x; then
19651 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19652 $as_echo "no" >&6; }
19653 else
19654 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19655 $as_echo "yes" >&6; }
19656 fi
19657 fi
19658 fi
19659
19660
19661 # Test if bash supports pipefail.
19662 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
19663 $as_echo_n "checking if bash supports pipefail... " >&6; }
19664 if ${BASH} -c 'set -o pipefail'; then
19665 BASH_ARGS="$BASH_ARGS -o pipefail"
19666 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19667 $as_echo "yes" >&6; }
19668 else
19669 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19670 $as_echo "no" >&6; }
19671 fi
19672
19673 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
19674 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
19675 if ${BASH} -e -c 'true'; then
19676 BASH_ARGS="$BASH_ARGS -e"
19677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19678 $as_echo "yes" >&6; }
19679 else
19680 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19681 $as_echo "no" >&6; }
19682 fi
19683
19684
19685
19686
19687 # Check if pkg-config is available.
19688
19689
19690 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19691 if test -n "$ac_tool_prefix"; then
19692 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19693 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19695 $as_echo_n "checking for $ac_word... " >&6; }
19696 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19697 $as_echo_n "(cached) " >&6
19698 else
19699 case $PKG_CONFIG in
19700 [\\/]* | ?:[\\/]*)
19701 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19702 ;;
19703 *)
19704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19705 for as_dir in $PATH
19706 do
19707 IFS=$as_save_IFS
19708 test -z "$as_dir" && as_dir=.
19709 for ac_exec_ext in '' $ac_executable_extensions; do
19710 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19711 ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19712 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19713 break 2
19714 fi
19715 done
19716 done
19717 IFS=$as_save_IFS
19718
19719 ;;
19720 esac
19721 fi
19722 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19723 if test -n "$PKG_CONFIG"; then
19724 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19725 $as_echo "$PKG_CONFIG" >&6; }
19726 else
19727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19728 $as_echo "no" >&6; }
19729 fi
19730
19731
19732 fi
19733 if test -z "$ac_cv_path_PKG_CONFIG"; then
19734 ac_pt_PKG_CONFIG=$PKG_CONFIG
19735 # Extract the first word of "pkg-config", so it can be a program name with args.
19736 set dummy pkg-config; ac_word=$2
19737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19738 $as_echo_n "checking for $ac_word... " >&6; }
19739 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19740 $as_echo_n "(cached) " >&6
19741 else
19742 case $ac_pt_PKG_CONFIG in
19743 [\\/]* | ?:[\\/]*)
19744 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19745 ;;
19746 *)
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_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
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 ;;
19763 esac
19764 fi
19765 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19766 if test -n "$ac_pt_PKG_CONFIG"; then
19767 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19768 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19769 else
19770 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19771 $as_echo "no" >&6; }
19772 fi
19773
19774 if test "x$ac_pt_PKG_CONFIG" = x; then
19775 PKG_CONFIG=""
19776 else
19777 case $cross_compiling:$ac_tool_warned in
19778 yes:)
19779 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19780 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19781 ac_tool_warned=yes ;;
19782 esac
19783 PKG_CONFIG=$ac_pt_PKG_CONFIG
19784 fi
19785 else
19786 PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19787 fi
19788
19789 fi
19790 if test -n "$PKG_CONFIG"; then
19791 _pkg_min_version=0.9.0
19792 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19793 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19794 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19796 $as_echo "yes" >&6; }
19797 else
19798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19799 $as_echo "no" >&6; }
19800 PKG_CONFIG=""
19801 fi
19802
19803 fi
19804
19805 # After basic tools have been setup, we can check build os specific details.
19806
19807 ###############################################################################
19808
19809 # Note that this is the build platform OS version!
19810
19811 OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19812 OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19813 OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19814 OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19815
19816
19817
19818
19819
19820 # Setup builddeps, for automatic downloading of tools we need.
19821 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19822 # boot-jdk setup, but we need to have basic tools setup first.
19823
19824
19825 # Check whether --with-builddeps-conf was given.
19826 if test "${with_builddeps_conf+set}" = set; then :
19827 withval=$with_builddeps_conf;
19828 fi
19829
19830
19831
19832 # Check whether --with-builddeps-server was given.
19833 if test "${with_builddeps_server+set}" = set; then :
19834 withval=$with_builddeps_server;
19835 fi
19836
19837
19838
19839 # Check whether --with-builddeps-dir was given.
19840 if test "${with_builddeps_dir+set}" = set; then :
19841 withval=$with_builddeps_dir;
19842 else
19843 with_builddeps_dir=/localhome/builddeps
19844 fi
19845
19846
19847
19848 # Check whether --with-builddeps-group was given.
19849 if test "${with_builddeps_group+set}" = set; then :
19850 withval=$with_builddeps_group;
19851 fi
19852
19853
19854
19855
19856 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19857 if test "x$with_builddeps_conf" != x; then
19858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19859 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19860 builddepsfile=$with_builddeps_conf
19861 if test -s $builddepsfile; then
19862 . $builddepsfile
19863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19864 $as_echo "loaded!" >&6; }
19865 else
19866 as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19867 fi
19868 else
19869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19870 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19871 builddepsfile=`mktemp`
19872 touch $builddepsfile
19873 # Put all found confs into a single file.
19874 find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19875 # Source the file to acquire the variables
19876 if test -s $builddepsfile; then
19877 . $builddepsfile
19878 { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19879 $as_echo "found at least one!" >&6; }
19880 else
19881 as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19882 fi
19883 fi
19884 # Create build and target names that use _ instead of "-" and ".".
19885 # This is necessary to use them in variable names.
19886 build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19887 target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19888 # Extract rewrite information for build and target
19889 eval rewritten_build=\${REWRITE_${build_var}}
19890 if test "x$rewritten_build" = x; then
19891 rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19892 echo Build stays the same $rewritten_build
19893 else
19894 echo Rewriting build for builddeps into $rewritten_build
19895 fi
19896 eval rewritten_target=\${REWRITE_${target_var}}
19897 if test "x$rewritten_target" = x; then
19898 rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19899 echo Target stays the same $rewritten_target
19900 else
19901 echo Rewriting target for builddeps into $rewritten_target
19902 fi
19903 rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19904 rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19905 fi
19906 for ac_prog in 7z unzip
19907 do
19908 # Extract the first word of "$ac_prog", so it can be a program name with args.
19909 set dummy $ac_prog; ac_word=$2
19910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19911 $as_echo_n "checking for $ac_word... " >&6; }
19912 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19913 $as_echo_n "(cached) " >&6
19914 else
19915 if test -n "$BDEPS_UNZIP"; then
19916 ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19917 else
19918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19919 for as_dir in $PATH
19920 do
19921 IFS=$as_save_IFS
19922 test -z "$as_dir" && as_dir=.
19923 for ac_exec_ext in '' $ac_executable_extensions; do
19924 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19925 ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19926 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19927 break 2
19928 fi
19929 done
19930 done
19931 IFS=$as_save_IFS
19932
19933 fi
19934 fi
19935 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19936 if test -n "$BDEPS_UNZIP"; then
19937 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19938 $as_echo "$BDEPS_UNZIP" >&6; }
19939 else
19940 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19941 $as_echo "no" >&6; }
19942 fi
19943
19944
19945 test -n "$BDEPS_UNZIP" && break
19946 done
19947
19948 if test "x$BDEPS_UNZIP" = x7z; then
19949 BDEPS_UNZIP="7z x"
19950 fi
19951
19952 for ac_prog in wget lftp ftp
19953 do
19954 # Extract the first word of "$ac_prog", so it can be a program name with args.
19955 set dummy $ac_prog; ac_word=$2
19956 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19957 $as_echo_n "checking for $ac_word... " >&6; }
19958 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19959 $as_echo_n "(cached) " >&6
19960 else
19961 if test -n "$BDEPS_FTP"; then
19962 ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19963 else
19964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19965 for as_dir in $PATH
19966 do
19967 IFS=$as_save_IFS
19968 test -z "$as_dir" && as_dir=.
19969 for ac_exec_ext in '' $ac_executable_extensions; do
19970 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19971 ac_cv_prog_BDEPS_FTP="$ac_prog"
19972 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19973 break 2
19974 fi
19975 done
19976 done
19977 IFS=$as_save_IFS
19978
19979 fi
19980 fi
19981 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19982 if test -n "$BDEPS_FTP"; then
19983 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19984 $as_echo "$BDEPS_FTP" >&6; }
19985 else
19986 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19987 $as_echo "no" >&6; }
19988 fi
19989
19990
19991 test -n "$BDEPS_FTP" && break
19992 done
19993
19994
19995
19996 ###############################################################################
19997 #
19998 # Determine OpenJDK variants, options and version numbers.
19999 #
20000 ###############################################################################
20001
20002 # We need build & target for this.
20003
20004
20005 ###############################################################################
20006 #
20007 # Should we build a JDK/JVM with headful support (ie a graphical ui)?
20008 # We always build headless support.
20009 #
20010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
20011 $as_echo_n "checking headful support... " >&6; }
20012 # Check whether --enable-headful was given.
20013 if test "${enable_headful+set}" = set; then :
20014 enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
20015 else
20016 SUPPORT_HEADFUL=yes
20017 fi
20018
20019
20020 SUPPORT_HEADLESS=yes
20021 BUILD_HEADLESS="BUILD_HEADLESS:=true"
20022
20023 if test "x$SUPPORT_HEADFUL" = xyes; then
20024 # We are building both headful and headless.
20025 headful_msg="include support for both headful and headless"
20026 fi
20027
20028 if test "x$SUPPORT_HEADFUL" = xno; then
20029 # Thus we are building headless only.
20030 BUILD_HEADLESS="BUILD_HEADLESS:=true"
20031 headful_msg="headless only"
20032 fi
20033
20034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
20035 $as_echo "$headful_msg" >&6; }
20036
20037
20038
20039
20040
20041 # Control wether Hotspot runs Queens test after build.
20042 # Check whether --enable-hotspot-test-in-build was given.
20043 if test "${enable_hotspot_test_in_build+set}" = set; then :
20044 enableval=$enable_hotspot_test_in_build;
20045 else
20046 enable_hotspot_test_in_build=no
20047 fi
20048
20049 if test "x$enable_hotspot_test_in_build" = "xyes"; then
20050 TEST_IN_BUILD=true
20051 else
20052 TEST_IN_BUILD=false
20053 fi
20054
20055
20056 ###############################################################################
20057 #
20058 # Choose cacerts source file
20059 #
20060
20061 # Check whether --with-cacerts-file was given.
20062 if test "${with_cacerts_file+set}" = set; then :
20063 withval=$with_cacerts_file;
20064 fi
20065
20066 if test "x$with_cacerts_file" != x; then
20067 CACERTS_FILE=$with_cacerts_file
20068 fi
20069
20070
20071 ###############################################################################
20072 #
20073 # Enable or disable unlimited crypto
20074 #
20075 # Check whether --enable-unlimited-crypto was given.
20076 if test "${enable_unlimited_crypto+set}" = set; then :
20077 enableval=$enable_unlimited_crypto;
20078 else
20079 enable_unlimited_crypto=no
20080 fi
20081
20082 if test "x$enable_unlimited_crypto" = "xyes"; then
20083 UNLIMITED_CRYPTO=true
20084 else
20085 UNLIMITED_CRYPTO=false
20086 fi
20087
20088
20089 ###############################################################################
20090 #
20091 # Enable or disable the elliptic curve crypto implementation
20092 #
20093
20094
20095 ###############################################################################
20096 #
20097 # --enable-rmiconnector-iiop
20098 #
20099 # Check whether --enable-rmiconnector-iiop was given.
20100 if test "${enable_rmiconnector_iiop+set}" = set; then :
20101 enableval=$enable_rmiconnector_iiop;
20102 fi
20103
20104 if test "x$enable_rmiconnector_iiop" = "xyes"; then
20105 RMICONNECTOR_IIOP=true
20106 else
20107 RMICONNECTOR_IIOP=false
20108 fi
20109
20110
20111 ###############################################################################
20112 #
20113 # Compress jars
20114 #
20115 COMPRESS_JARS=false
20116
20117
20118
20119
20120 # Source the version numbers
20121 . $AUTOCONF_DIR/version-numbers
20122
20123 # Get the settings from parameters
20124
20125 # Check whether --with-milestone was given.
20126 if test "${with_milestone+set}" = set; then :
20127 withval=$with_milestone;
20128 fi
20129
20130 if test "x$with_milestone" = xyes; then
20131 as_fn_error $? "Milestone must have a value" "$LINENO" 5
20132 elif test "x$with_milestone" != x; then
20133 MILESTONE="$with_milestone"
20134 fi
20135 if test "x$MILESTONE" = x; then
20136 MILESTONE=internal
20137 fi
20138
20139
20140 # Check whether --with-update-version was given.
20141 if test "${with_update_version+set}" = set; then :
20142 withval=$with_update_version;
20143 fi
20144
20145 if test "x$with_update_version" = xyes; then
20146 as_fn_error $? "Update version must have a value" "$LINENO" 5
20147 elif test "x$with_update_version" != x; then
20148 JDK_UPDATE_VERSION="$with_update_version"
20149 # On macosx 10.7, it's not possible to set --with-update-version=0X due
20150 # to a bug in expr (which reduces it to just X). To work around this, we
20151 # always add a 0 to one digit update versions.
20152 if test "${#JDK_UPDATE_VERSION}" = "1"; then
20153 JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
20154 fi
20155 fi
20156
20157
20158 # Check whether --with-user-release-suffix was given.
20159 if test "${with_user_release_suffix+set}" = set; then :
20160 withval=$with_user_release_suffix;
20161 fi
20162
20163 if test "x$with_user_release_suffix" = xyes; then
20164 as_fn_error $? "Release suffix must have a value" "$LINENO" 5
20165 elif test "x$with_user_release_suffix" != x; then
20166 USER_RELEASE_SUFFIX="$with_user_release_suffix"
20167 fi
20168
20169
20170 # Check whether --with-build-number was given.
20171 if test "${with_build_number+set}" = set; then :
20172 withval=$with_build_number;
20173 fi
20174
20175 if test "x$with_build_number" = xyes; then
20176 as_fn_error $? "Build number must have a value" "$LINENO" 5
20177 elif test "x$with_build_number" != x; then
20178 JDK_BUILD_NUMBER="$with_build_number"
20179 fi
20180 # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
20181 if test "x$JDK_BUILD_NUMBER" = x; then
20182 JDK_BUILD_NUMBER=b00
20183 if test "x$USER_RELEASE_SUFFIX" = x; then
20184 BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
20185 # Avoid [:alnum:] since it depends on the locale.
20186 CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
20187 USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20188 fi
20189 fi
20190
20191 # Now set the JDK version, milestone, build number etc.
20192
20193
20194
20195
20196
20197
20198
20199
20200
20201
20202
20203
20204
20205
20206
20207
20208 # Check whether --with-copyright-year was given.
20209 if test "${with_copyright_year+set}" = set; then :
20210 withval=$with_copyright_year;
20211 fi
20212
20213 if test "x$with_copyright_year" = xyes; then
20214 as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20215 elif test "x$with_copyright_year" != x; then
20216 COPYRIGHT_YEAR="$with_copyright_year"
20217 else
20218 COPYRIGHT_YEAR=`date +'%Y'`
20219 fi
20220
20221
20222 if test "x$JDK_UPDATE_VERSION" != x; then
20223 JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
20224 else
20225 JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
20226 fi
20227
20228
20229 COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
20230
20231
20232
20233 ###############################################################################
20234 #
20235 # Setup BootJDK, used to bootstrap the build.
20236 #
20237 ###############################################################################
20238
20239
20240 BOOT_JDK_FOUND=no
20241
20242 # Check whether --with-boot-jdk was given.
20243 if test "${with_boot_jdk+set}" = set; then :
20244 withval=$with_boot_jdk;
20245 fi
20246
20247
20248 # We look for the Boot JDK through various means, going from more certain to
20249 # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20250 # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20251 # must check if this is indeed valid; otherwise we'll continue looking.
20252
20253 # Test: Is bootjdk explicitely set by command line arguments?
20254
20255 if test "x$BOOT_JDK_FOUND" = xno; then
20256 # Now execute the test
20257
20258 if test "x$with_boot_jdk" != x; then
20259 BOOT_JDK=$with_boot_jdk
20260 BOOT_JDK_FOUND=maybe
20261 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20262 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20263 fi
20264
20265
20266 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20267 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20268 # Do we have a bin/java?
20269 if test ! -x "$BOOT_JDK/bin/java"; then
20270 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20271 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20272 BOOT_JDK_FOUND=no
20273 else
20274 # Do we have a bin/javac?
20275 if test ! -x "$BOOT_JDK/bin/javac"; then
20276 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20277 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20278 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20279 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20280 BOOT_JDK_FOUND=no
20281 else
20282 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20283 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20284
20285 # Extra M4 quote needed to protect [] in grep expression.
20286 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20287 if test "x$FOUND_CORRECT_VERSION" = x; then
20288 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20289 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20290 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20291 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20292 BOOT_JDK_FOUND=no
20293 else
20294 # We're done! :-)
20295 BOOT_JDK_FOUND=yes
20296
20297 # Only process if variable expands to non-empty
20298
20299 if test "x$BOOT_JDK" != x; then
20300 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20301
20302 # Input might be given as Windows format, start by converting to
20303 # unix format.
20304 path="$BOOT_JDK"
20305 new_path=`$CYGPATH -u "$path"`
20306
20307 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20308 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20309 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20310 # "foo.exe" is OK but "foo" is an error.
20311 #
20312 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20313 # It is also a way to make sure we got the proper file name for the real test later on.
20314 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20315 if test "x$test_shortpath" = x; then
20316 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20317 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20318 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20319 fi
20320
20321 # Call helper function which possibly converts this using DOS-style short mode.
20322 # If so, the updated path is stored in $new_path.
20323
20324 input_path="$new_path"
20325 # Check if we need to convert this using DOS-style short mode. If the path
20326 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20327 # take no chances and rewrite it.
20328 # Note: m4 eats our [], so we need to use [ and ] instead.
20329 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20330 if test "x$has_forbidden_chars" != x; then
20331 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20332 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20333 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20334 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20335 # Going to short mode and back again did indeed matter. Since short mode is
20336 # case insensitive, let's make it lowercase to improve readability.
20337 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20338 # Now convert it back to Unix-style (cygpath)
20339 input_path=`$CYGPATH -u "$shortmode_path"`
20340 new_path="$input_path"
20341 fi
20342 fi
20343
20344 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20345 if test "x$test_cygdrive_prefix" = x; then
20346 # As a simple fix, exclude /usr/bin since it's not a real path.
20347 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20348 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20349 # a path prefixed by /cygdrive for fixpath to work.
20350 new_path="$CYGWIN_ROOT_PATH$input_path"
20351 fi
20352 fi
20353
20354
20355 if test "x$path" != "x$new_path"; then
20356 BOOT_JDK="$new_path"
20357 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20358 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20359 fi
20360
20361 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20362
20363 path="$BOOT_JDK"
20364 has_colon=`$ECHO $path | $GREP ^.:`
20365 new_path="$path"
20366 if test "x$has_colon" = x; then
20367 # Not in mixed or Windows style, start by that.
20368 new_path=`cmd //c echo $path`
20369 fi
20370
20371
20372 input_path="$new_path"
20373 # Check if we need to convert this using DOS-style short mode. If the path
20374 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20375 # take no chances and rewrite it.
20376 # Note: m4 eats our [], so we need to use [ and ] instead.
20377 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20378 if test "x$has_forbidden_chars" != x; then
20379 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20380 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20381 fi
20382
20383
20384 windows_path="$new_path"
20385 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20386 unix_path=`$CYGPATH -u "$windows_path"`
20387 new_path="$unix_path"
20388 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20389 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20390 new_path="$unix_path"
20391 fi
20392
20393 if test "x$path" != "x$new_path"; then
20394 BOOT_JDK="$new_path"
20395 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20396 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20397 fi
20398
20399 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20400 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20401
20402 else
20403 # We're on a unix platform. Hooray! :)
20404 path="$BOOT_JDK"
20405 has_space=`$ECHO "$path" | $GREP " "`
20406 if test "x$has_space" != x; then
20407 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20408 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20409 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20410 fi
20411
20412 # Use eval to expand a potential ~
20413 eval path="$path"
20414 if test ! -f "$path" && test ! -d "$path"; then
20415 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20416 fi
20417
20418 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20419 fi
20420 fi
20421
20422 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20423 $as_echo_n "checking for Boot JDK... " >&6; }
20424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20425 $as_echo "$BOOT_JDK" >&6; }
20426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20427 $as_echo_n "checking Boot JDK version... " >&6; }
20428 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20429 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20430 $as_echo "$BOOT_JDK_VERSION" >&6; }
20431 fi # end check jdk version
20432 fi # end check javac
20433 fi # end check java
20434 fi # end check boot jdk found
20435 fi
20436
20437 if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20438 # Having specified an argument which is incorrect will produce an instant failure;
20439 # we should not go on looking
20440 as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20441 fi
20442
20443 # Test: Is bootjdk available from builddeps?
20444
20445 if test "x$BOOT_JDK_FOUND" = xno; then
20446 # Now execute the test
20447
20448
20449
20450 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20451 # Source the builddeps file again, to make sure it uses the latest variables!
20452 . $builddepsfile
20453 # Look for a target and build machine specific resource!
20454 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20455 if test "x$resource" = x; then
20456 # Ok, lets instead look for a target specific resource
20457 eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20458 fi
20459 if test "x$resource" = x; then
20460 # Ok, lets instead look for a build specific resource
20461 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20462 fi
20463 if test "x$resource" = x; then
20464 # Ok, lets instead look for a generic resource
20465 # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20466 resource=${builddep_bootjdk}
20467 fi
20468 if test "x$resource" != x; then
20469 { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20470 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20471 # If the resource in the builddeps.conf file is an existing directory,
20472 # for example /java/linux/cups
20473 if test -d ${resource}; then
20474 depdir=${resource}
20475 else
20476
20477 # bootjdk is for example mymodule
20478 # $resource is for example libs/general/libmymod_1_2_3.zip
20479 # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20480 # $with_builddeps_dir is for example /localhome/builddeps
20481 # depdir is the name of the variable into which we store the depdir, eg MYMOD
20482 # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20483 # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20484 filename=`basename $resource`
20485 filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20486 filebase=${filename%%.*}
20487 extension=${filename#*.}
20488 installdir=$with_builddeps_dir/$filebase
20489 if test ! -f $installdir/$filename.unpacked; then
20490 { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20491 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20492 if test ! -d $installdir; then
20493 mkdir -p $installdir
20494 fi
20495 if test ! -d $installdir; then
20496 as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20497 fi
20498 tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20499 touch $tmpfile
20500 if test ! -f $tmpfile; then
20501 as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20502 fi
20503
20504 # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip
20505 # $tmpfile is the local file name for the downloaded file.
20506 VALID_TOOL=no
20507 if test "x$BDEPS_FTP" = xwget; then
20508 VALID_TOOL=yes
20509 wget -O $tmpfile $with_builddeps_server/$resource
20510 fi
20511 if test "x$BDEPS_FTP" = xlftp; then
20512 VALID_TOOL=yes
20513 lftp -c "get $with_builddeps_server/$resource -o $tmpfile"
20514 fi
20515 if test "x$BDEPS_FTP" = xftp; then
20516 VALID_TOOL=yes
20517 FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'`
20518 FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'`
20519 FTPUSERPWD=${FTPSERVER%%@*}
20520 if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20521 FTPUSER=${userpwd%%:*}
20522 FTPPWD=${userpwd#*@}
20523 FTPSERVER=${FTPSERVER#*@}
20524 else
20525 FTPUSER=ftp
20526 FTPPWD=ftp
20527 fi
20528 # the "pass" command does not work on some
20529 # ftp clients (read ftp.exe) but if it works,
20530 # passive mode is better!
20531 ( \
20532 echo "user $FTPUSER $FTPPWD" ; \
20533 echo "pass" ; \
20534 echo "bin" ; \
20535 echo "get $FTPPATH $tmpfile" ; \
20536 ) | ftp -in $FTPSERVER
20537 fi
20538 if test "x$VALID_TOOL" != xyes; then
20539 as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20540 fi
20541
20542 mv $tmpfile $installdir/$filename
20543 if test ! -s $installdir/$filename; then
20544 as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20545 fi
20546 case "$extension" in
20547 zip) echo "Unzipping $installdir/$filename..."
20548 (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20549 ;;
20550 tar.gz) echo "Untaring $installdir/$filename..."
20551 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20552 ;;
20553 tgz) echo "Untaring $installdir/$filename..."
20554 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20555 ;;
20556 *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20557 ;;
20558 esac
20559 fi
20560 if test -f $installdir/$filename.unpacked; then
20561 depdir=$installdir
20562 fi
20563
20564 fi
20565 # Source the builddeps file again, because in the previous command, the depdir
20566 # was updated to point at the current build dependency install directory.
20567 . $builddepsfile
20568 # Now extract variables from the builddeps.conf files.
20569 theroot=${builddep_bootjdk_ROOT}
20570 thecflags=${builddep_bootjdk_CFLAGS}
20571 thelibs=${builddep_bootjdk_LIBS}
20572 if test "x$depdir" = x; then
20573 as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20574 fi
20575 BOOT_JDK=$depdir
20576 if test "x$theroot" != x; then
20577 BOOT_JDK="$theroot"
20578 fi
20579 if test "x$thecflags" != x; then
20580 BOOT_JDK_CFLAGS="$thecflags"
20581 fi
20582 if test "x$thelibs" != x; then
20583 BOOT_JDK_LIBS="$thelibs"
20584 fi
20585 BOOT_JDK_FOUND=maybe
20586 else BOOT_JDK_FOUND=no
20587
20588 fi
20589 else BOOT_JDK_FOUND=no
20590
20591 fi
20592
20593
20594
20595 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20596 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20597 # Do we have a bin/java?
20598 if test ! -x "$BOOT_JDK/bin/java"; then
20599 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20600 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20601 BOOT_JDK_FOUND=no
20602 else
20603 # Do we have a bin/javac?
20604 if test ! -x "$BOOT_JDK/bin/javac"; then
20605 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20606 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20607 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20608 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20609 BOOT_JDK_FOUND=no
20610 else
20611 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20612 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20613
20614 # Extra M4 quote needed to protect [] in grep expression.
20615 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20616 if test "x$FOUND_CORRECT_VERSION" = x; then
20617 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20618 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20619 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20620 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20621 BOOT_JDK_FOUND=no
20622 else
20623 # We're done! :-)
20624 BOOT_JDK_FOUND=yes
20625
20626 # Only process if variable expands to non-empty
20627
20628 if test "x$BOOT_JDK" != x; then
20629 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20630
20631 # Input might be given as Windows format, start by converting to
20632 # unix format.
20633 path="$BOOT_JDK"
20634 new_path=`$CYGPATH -u "$path"`
20635
20636 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20637 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20638 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20639 # "foo.exe" is OK but "foo" is an error.
20640 #
20641 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20642 # It is also a way to make sure we got the proper file name for the real test later on.
20643 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20644 if test "x$test_shortpath" = x; then
20645 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20646 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20647 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20648 fi
20649
20650 # Call helper function which possibly converts this using DOS-style short mode.
20651 # If so, the updated path is stored in $new_path.
20652
20653 input_path="$new_path"
20654 # Check if we need to convert this using DOS-style short mode. If the path
20655 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20656 # take no chances and rewrite it.
20657 # Note: m4 eats our [], so we need to use [ and ] instead.
20658 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20659 if test "x$has_forbidden_chars" != x; then
20660 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20661 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20662 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20663 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20664 # Going to short mode and back again did indeed matter. Since short mode is
20665 # case insensitive, let's make it lowercase to improve readability.
20666 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20667 # Now convert it back to Unix-style (cygpath)
20668 input_path=`$CYGPATH -u "$shortmode_path"`
20669 new_path="$input_path"
20670 fi
20671 fi
20672
20673 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20674 if test "x$test_cygdrive_prefix" = x; then
20675 # As a simple fix, exclude /usr/bin since it's not a real path.
20676 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20677 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20678 # a path prefixed by /cygdrive for fixpath to work.
20679 new_path="$CYGWIN_ROOT_PATH$input_path"
20680 fi
20681 fi
20682
20683
20684 if test "x$path" != "x$new_path"; then
20685 BOOT_JDK="$new_path"
20686 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20687 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20688 fi
20689
20690 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20691
20692 path="$BOOT_JDK"
20693 has_colon=`$ECHO $path | $GREP ^.:`
20694 new_path="$path"
20695 if test "x$has_colon" = x; then
20696 # Not in mixed or Windows style, start by that.
20697 new_path=`cmd //c echo $path`
20698 fi
20699
20700
20701 input_path="$new_path"
20702 # Check if we need to convert this using DOS-style short mode. If the path
20703 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20704 # take no chances and rewrite it.
20705 # Note: m4 eats our [], so we need to use [ and ] instead.
20706 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20707 if test "x$has_forbidden_chars" != x; then
20708 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20709 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20710 fi
20711
20712
20713 windows_path="$new_path"
20714 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20715 unix_path=`$CYGPATH -u "$windows_path"`
20716 new_path="$unix_path"
20717 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20718 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20719 new_path="$unix_path"
20720 fi
20721
20722 if test "x$path" != "x$new_path"; then
20723 BOOT_JDK="$new_path"
20724 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20725 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20726 fi
20727
20728 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20729 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20730
20731 else
20732 # We're on a unix platform. Hooray! :)
20733 path="$BOOT_JDK"
20734 has_space=`$ECHO "$path" | $GREP " "`
20735 if test "x$has_space" != x; then
20736 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20737 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20738 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20739 fi
20740
20741 # Use eval to expand a potential ~
20742 eval path="$path"
20743 if test ! -f "$path" && test ! -d "$path"; then
20744 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20745 fi
20746
20747 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20748 fi
20749 fi
20750
20751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20752 $as_echo_n "checking for Boot JDK... " >&6; }
20753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20754 $as_echo "$BOOT_JDK" >&6; }
20755 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20756 $as_echo_n "checking Boot JDK version... " >&6; }
20757 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20759 $as_echo "$BOOT_JDK_VERSION" >&6; }
20760 fi # end check jdk version
20761 fi # end check javac
20762 fi # end check java
20763 fi # end check boot jdk found
20764 fi
20765
20766
20767 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20768
20769 if test "x$BOOT_JDK_FOUND" = xno; then
20770 # Now execute the test
20771
20772 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20773 # First check at user selected default
20774
20775 if test "x$BOOT_JDK_FOUND" = xno; then
20776 # Now execute the test
20777
20778 if test -x /usr/libexec/java_home; then
20779 BOOT_JDK=`/usr/libexec/java_home `
20780 BOOT_JDK_FOUND=maybe
20781 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20782 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20783 fi
20784
20785
20786 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20787 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20788 # Do we have a bin/java?
20789 if test ! -x "$BOOT_JDK/bin/java"; then
20790 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20791 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20792 BOOT_JDK_FOUND=no
20793 else
20794 # Do we have a bin/javac?
20795 if test ! -x "$BOOT_JDK/bin/javac"; then
20796 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20797 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20798 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20799 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20800 BOOT_JDK_FOUND=no
20801 else
20802 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20803 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20804
20805 # Extra M4 quote needed to protect [] in grep expression.
20806 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20807 if test "x$FOUND_CORRECT_VERSION" = x; then
20808 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20809 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20810 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20811 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20812 BOOT_JDK_FOUND=no
20813 else
20814 # We're done! :-)
20815 BOOT_JDK_FOUND=yes
20816
20817 # Only process if variable expands to non-empty
20818
20819 if test "x$BOOT_JDK" != x; then
20820 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20821
20822 # Input might be given as Windows format, start by converting to
20823 # unix format.
20824 path="$BOOT_JDK"
20825 new_path=`$CYGPATH -u "$path"`
20826
20827 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20828 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20829 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20830 # "foo.exe" is OK but "foo" is an error.
20831 #
20832 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20833 # It is also a way to make sure we got the proper file name for the real test later on.
20834 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20835 if test "x$test_shortpath" = x; then
20836 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20837 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20838 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20839 fi
20840
20841 # Call helper function which possibly converts this using DOS-style short mode.
20842 # If so, the updated path is stored in $new_path.
20843
20844 input_path="$new_path"
20845 # Check if we need to convert this using DOS-style short mode. If the path
20846 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20847 # take no chances and rewrite it.
20848 # Note: m4 eats our [], so we need to use [ and ] instead.
20849 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20850 if test "x$has_forbidden_chars" != x; then
20851 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20852 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20853 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20854 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20855 # Going to short mode and back again did indeed matter. Since short mode is
20856 # case insensitive, let's make it lowercase to improve readability.
20857 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20858 # Now convert it back to Unix-style (cygpath)
20859 input_path=`$CYGPATH -u "$shortmode_path"`
20860 new_path="$input_path"
20861 fi
20862 fi
20863
20864 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20865 if test "x$test_cygdrive_prefix" = x; then
20866 # As a simple fix, exclude /usr/bin since it's not a real path.
20867 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20868 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20869 # a path prefixed by /cygdrive for fixpath to work.
20870 new_path="$CYGWIN_ROOT_PATH$input_path"
20871 fi
20872 fi
20873
20874
20875 if test "x$path" != "x$new_path"; then
20876 BOOT_JDK="$new_path"
20877 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20878 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20879 fi
20880
20881 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20882
20883 path="$BOOT_JDK"
20884 has_colon=`$ECHO $path | $GREP ^.:`
20885 new_path="$path"
20886 if test "x$has_colon" = x; then
20887 # Not in mixed or Windows style, start by that.
20888 new_path=`cmd //c echo $path`
20889 fi
20890
20891
20892 input_path="$new_path"
20893 # Check if we need to convert this using DOS-style short mode. If the path
20894 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20895 # take no chances and rewrite it.
20896 # Note: m4 eats our [], so we need to use [ and ] instead.
20897 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20898 if test "x$has_forbidden_chars" != x; then
20899 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20900 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20901 fi
20902
20903
20904 windows_path="$new_path"
20905 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20906 unix_path=`$CYGPATH -u "$windows_path"`
20907 new_path="$unix_path"
20908 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20909 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20910 new_path="$unix_path"
20911 fi
20912
20913 if test "x$path" != "x$new_path"; then
20914 BOOT_JDK="$new_path"
20915 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20916 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20917 fi
20918
20919 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20920 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20921
20922 else
20923 # We're on a unix platform. Hooray! :)
20924 path="$BOOT_JDK"
20925 has_space=`$ECHO "$path" | $GREP " "`
20926 if test "x$has_space" != x; then
20927 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20928 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20929 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20930 fi
20931
20932 # Use eval to expand a potential ~
20933 eval path="$path"
20934 if test ! -f "$path" && test ! -d "$path"; then
20935 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20936 fi
20937
20938 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20939 fi
20940 fi
20941
20942 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20943 $as_echo_n "checking for Boot JDK... " >&6; }
20944 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20945 $as_echo "$BOOT_JDK" >&6; }
20946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20947 $as_echo_n "checking Boot JDK version... " >&6; }
20948 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20949 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20950 $as_echo "$BOOT_JDK_VERSION" >&6; }
20951 fi # end check jdk version
20952 fi # end check javac
20953 fi # end check java
20954 fi # end check boot jdk found
20955 fi
20956
20957 # If that did not work out (e.g. too old), try explicit versions instead
20958
20959 if test "x$BOOT_JDK_FOUND" = xno; then
20960 # Now execute the test
20961
20962 if test -x /usr/libexec/java_home; then
20963 BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20964 BOOT_JDK_FOUND=maybe
20965 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20966 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20967 fi
20968
20969
20970 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20971 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20972 # Do we have a bin/java?
20973 if test ! -x "$BOOT_JDK/bin/java"; then
20974 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20975 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20976 BOOT_JDK_FOUND=no
20977 else
20978 # Do we have a bin/javac?
20979 if test ! -x "$BOOT_JDK/bin/javac"; then
20980 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20981 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20982 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20983 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20984 BOOT_JDK_FOUND=no
20985 else
20986 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20987 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20988
20989 # Extra M4 quote needed to protect [] in grep expression.
20990 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20991 if test "x$FOUND_CORRECT_VERSION" = x; then
20992 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20993 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20994 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20995 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20996 BOOT_JDK_FOUND=no
20997 else
20998 # We're done! :-)
20999 BOOT_JDK_FOUND=yes
21000
21001 # Only process if variable expands to non-empty
21002
21003 if test "x$BOOT_JDK" != x; then
21004 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21005
21006 # Input might be given as Windows format, start by converting to
21007 # unix format.
21008 path="$BOOT_JDK"
21009 new_path=`$CYGPATH -u "$path"`
21010
21011 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21012 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21013 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21014 # "foo.exe" is OK but "foo" is an error.
21015 #
21016 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21017 # It is also a way to make sure we got the proper file name for the real test later on.
21018 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21019 if test "x$test_shortpath" = x; then
21020 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21021 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21022 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21023 fi
21024
21025 # Call helper function which possibly converts this using DOS-style short mode.
21026 # If so, the updated path is stored in $new_path.
21027
21028 input_path="$new_path"
21029 # Check if we need to convert this using DOS-style short mode. If the path
21030 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21031 # take no chances and rewrite it.
21032 # Note: m4 eats our [], so we need to use [ and ] instead.
21033 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21034 if test "x$has_forbidden_chars" != x; then
21035 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21036 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21037 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21038 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21039 # Going to short mode and back again did indeed matter. Since short mode is
21040 # case insensitive, let's make it lowercase to improve readability.
21041 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21042 # Now convert it back to Unix-style (cygpath)
21043 input_path=`$CYGPATH -u "$shortmode_path"`
21044 new_path="$input_path"
21045 fi
21046 fi
21047
21048 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21049 if test "x$test_cygdrive_prefix" = x; then
21050 # As a simple fix, exclude /usr/bin since it's not a real path.
21051 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21052 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21053 # a path prefixed by /cygdrive for fixpath to work.
21054 new_path="$CYGWIN_ROOT_PATH$input_path"
21055 fi
21056 fi
21057
21058
21059 if test "x$path" != "x$new_path"; then
21060 BOOT_JDK="$new_path"
21061 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21062 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21063 fi
21064
21065 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21066
21067 path="$BOOT_JDK"
21068 has_colon=`$ECHO $path | $GREP ^.:`
21069 new_path="$path"
21070 if test "x$has_colon" = x; then
21071 # Not in mixed or Windows style, start by that.
21072 new_path=`cmd //c echo $path`
21073 fi
21074
21075
21076 input_path="$new_path"
21077 # Check if we need to convert this using DOS-style short mode. If the path
21078 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21079 # take no chances and rewrite it.
21080 # Note: m4 eats our [], so we need to use [ and ] instead.
21081 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21082 if test "x$has_forbidden_chars" != x; then
21083 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21084 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21085 fi
21086
21087
21088 windows_path="$new_path"
21089 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21090 unix_path=`$CYGPATH -u "$windows_path"`
21091 new_path="$unix_path"
21092 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21093 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21094 new_path="$unix_path"
21095 fi
21096
21097 if test "x$path" != "x$new_path"; then
21098 BOOT_JDK="$new_path"
21099 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21100 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21101 fi
21102
21103 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21104 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21105
21106 else
21107 # We're on a unix platform. Hooray! :)
21108 path="$BOOT_JDK"
21109 has_space=`$ECHO "$path" | $GREP " "`
21110 if test "x$has_space" != x; then
21111 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21112 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21113 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21114 fi
21115
21116 # Use eval to expand a potential ~
21117 eval path="$path"
21118 if test ! -f "$path" && test ! -d "$path"; then
21119 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21120 fi
21121
21122 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21123 fi
21124 fi
21125
21126 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21127 $as_echo_n "checking for Boot JDK... " >&6; }
21128 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21129 $as_echo "$BOOT_JDK" >&6; }
21130 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21131 $as_echo_n "checking Boot JDK version... " >&6; }
21132 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21133 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21134 $as_echo "$BOOT_JDK_VERSION" >&6; }
21135 fi # end check jdk version
21136 fi # end check javac
21137 fi # end check java
21138 fi # end check boot jdk found
21139 fi
21140
21141
21142 if test "x$BOOT_JDK_FOUND" = xno; then
21143 # Now execute the test
21144
21145 if test -x /usr/libexec/java_home; then
21146 BOOT_JDK=`/usr/libexec/java_home -v 1.8`
21147 BOOT_JDK_FOUND=maybe
21148 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
21149 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
21150 fi
21151
21152
21153 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21154 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21155 # Do we have a bin/java?
21156 if test ! -x "$BOOT_JDK/bin/java"; then
21157 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21158 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21159 BOOT_JDK_FOUND=no
21160 else
21161 # Do we have a bin/javac?
21162 if test ! -x "$BOOT_JDK/bin/javac"; then
21163 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21164 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21165 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21166 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21167 BOOT_JDK_FOUND=no
21168 else
21169 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21170 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21171
21172 # Extra M4 quote needed to protect [] in grep expression.
21173 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21174 if test "x$FOUND_CORRECT_VERSION" = x; then
21175 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21176 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21177 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21178 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21179 BOOT_JDK_FOUND=no
21180 else
21181 # We're done! :-)
21182 BOOT_JDK_FOUND=yes
21183
21184 # Only process if variable expands to non-empty
21185
21186 if test "x$BOOT_JDK" != x; then
21187 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21188
21189 # Input might be given as Windows format, start by converting to
21190 # unix format.
21191 path="$BOOT_JDK"
21192 new_path=`$CYGPATH -u "$path"`
21193
21194 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21195 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21196 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21197 # "foo.exe" is OK but "foo" is an error.
21198 #
21199 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21200 # It is also a way to make sure we got the proper file name for the real test later on.
21201 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21202 if test "x$test_shortpath" = x; then
21203 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21204 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21205 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21206 fi
21207
21208 # Call helper function which possibly converts this using DOS-style short mode.
21209 # If so, the updated path is stored in $new_path.
21210
21211 input_path="$new_path"
21212 # Check if we need to convert this using DOS-style short mode. If the path
21213 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21214 # take no chances and rewrite it.
21215 # Note: m4 eats our [], so we need to use [ and ] instead.
21216 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21217 if test "x$has_forbidden_chars" != x; then
21218 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21219 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21220 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21221 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21222 # Going to short mode and back again did indeed matter. Since short mode is
21223 # case insensitive, let's make it lowercase to improve readability.
21224 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21225 # Now convert it back to Unix-style (cygpath)
21226 input_path=`$CYGPATH -u "$shortmode_path"`
21227 new_path="$input_path"
21228 fi
21229 fi
21230
21231 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21232 if test "x$test_cygdrive_prefix" = x; then
21233 # As a simple fix, exclude /usr/bin since it's not a real path.
21234 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21235 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21236 # a path prefixed by /cygdrive for fixpath to work.
21237 new_path="$CYGWIN_ROOT_PATH$input_path"
21238 fi
21239 fi
21240
21241
21242 if test "x$path" != "x$new_path"; then
21243 BOOT_JDK="$new_path"
21244 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21245 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21246 fi
21247
21248 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21249
21250 path="$BOOT_JDK"
21251 has_colon=`$ECHO $path | $GREP ^.:`
21252 new_path="$path"
21253 if test "x$has_colon" = x; then
21254 # Not in mixed or Windows style, start by that.
21255 new_path=`cmd //c echo $path`
21256 fi
21257
21258
21259 input_path="$new_path"
21260 # Check if we need to convert this using DOS-style short mode. If the path
21261 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21262 # take no chances and rewrite it.
21263 # Note: m4 eats our [], so we need to use [ and ] instead.
21264 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21265 if test "x$has_forbidden_chars" != x; then
21266 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21267 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21268 fi
21269
21270
21271 windows_path="$new_path"
21272 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21273 unix_path=`$CYGPATH -u "$windows_path"`
21274 new_path="$unix_path"
21275 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21276 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21277 new_path="$unix_path"
21278 fi
21279
21280 if test "x$path" != "x$new_path"; then
21281 BOOT_JDK="$new_path"
21282 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21283 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21284 fi
21285
21286 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21287 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21288
21289 else
21290 # We're on a unix platform. Hooray! :)
21291 path="$BOOT_JDK"
21292 has_space=`$ECHO "$path" | $GREP " "`
21293 if test "x$has_space" != x; then
21294 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21295 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21296 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21297 fi
21298
21299 # Use eval to expand a potential ~
21300 eval path="$path"
21301 if test ! -f "$path" && test ! -d "$path"; then
21302 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21303 fi
21304
21305 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21306 fi
21307 fi
21308
21309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21310 $as_echo_n "checking for Boot JDK... " >&6; }
21311 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21312 $as_echo "$BOOT_JDK" >&6; }
21313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21314 $as_echo_n "checking Boot JDK version... " >&6; }
21315 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21316 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21317 $as_echo "$BOOT_JDK_VERSION" >&6; }
21318 fi # end check jdk version
21319 fi # end check javac
21320 fi # end check java
21321 fi # end check boot jdk found
21322 fi
21323
21324
21325 if test "x$BOOT_JDK_FOUND" = xno; then
21326 # Now execute the test
21327
21328 if test -x /usr/libexec/java_home; then
21329 BOOT_JDK=`/usr/libexec/java_home -v 1.7`
21330 BOOT_JDK_FOUND=maybe
21331 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
21332 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
21333 fi
21334
21335
21336 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21337 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21338 # Do we have a bin/java?
21339 if test ! -x "$BOOT_JDK/bin/java"; then
21340 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21341 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21342 BOOT_JDK_FOUND=no
21343 else
21344 # Do we have a bin/javac?
21345 if test ! -x "$BOOT_JDK/bin/javac"; then
21346 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21347 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21348 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21349 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21350 BOOT_JDK_FOUND=no
21351 else
21352 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21353 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21354
21355 # Extra M4 quote needed to protect [] in grep expression.
21356 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21357 if test "x$FOUND_CORRECT_VERSION" = x; then
21358 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21359 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21360 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21361 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21362 BOOT_JDK_FOUND=no
21363 else
21364 # We're done! :-)
21365 BOOT_JDK_FOUND=yes
21366
21367 # Only process if variable expands to non-empty
21368
21369 if test "x$BOOT_JDK" != x; then
21370 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21371
21372 # Input might be given as Windows format, start by converting to
21373 # unix format.
21374 path="$BOOT_JDK"
21375 new_path=`$CYGPATH -u "$path"`
21376
21377 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21378 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21379 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21380 # "foo.exe" is OK but "foo" is an error.
21381 #
21382 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21383 # It is also a way to make sure we got the proper file name for the real test later on.
21384 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21385 if test "x$test_shortpath" = x; then
21386 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21387 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21388 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21389 fi
21390
21391 # Call helper function which possibly converts this using DOS-style short mode.
21392 # If so, the updated path is stored in $new_path.
21393
21394 input_path="$new_path"
21395 # Check if we need to convert this using DOS-style short mode. If the path
21396 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21397 # take no chances and rewrite it.
21398 # Note: m4 eats our [], so we need to use [ and ] instead.
21399 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21400 if test "x$has_forbidden_chars" != x; then
21401 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21402 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21403 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21404 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21405 # Going to short mode and back again did indeed matter. Since short mode is
21406 # case insensitive, let's make it lowercase to improve readability.
21407 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21408 # Now convert it back to Unix-style (cygpath)
21409 input_path=`$CYGPATH -u "$shortmode_path"`
21410 new_path="$input_path"
21411 fi
21412 fi
21413
21414 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21415 if test "x$test_cygdrive_prefix" = x; then
21416 # As a simple fix, exclude /usr/bin since it's not a real path.
21417 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21418 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21419 # a path prefixed by /cygdrive for fixpath to work.
21420 new_path="$CYGWIN_ROOT_PATH$input_path"
21421 fi
21422 fi
21423
21424
21425 if test "x$path" != "x$new_path"; then
21426 BOOT_JDK="$new_path"
21427 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21428 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21429 fi
21430
21431 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21432
21433 path="$BOOT_JDK"
21434 has_colon=`$ECHO $path | $GREP ^.:`
21435 new_path="$path"
21436 if test "x$has_colon" = x; then
21437 # Not in mixed or Windows style, start by that.
21438 new_path=`cmd //c echo $path`
21439 fi
21440
21441
21442 input_path="$new_path"
21443 # Check if we need to convert this using DOS-style short mode. If the path
21444 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21445 # take no chances and rewrite it.
21446 # Note: m4 eats our [], so we need to use [ and ] instead.
21447 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21448 if test "x$has_forbidden_chars" != x; then
21449 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21450 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21451 fi
21452
21453
21454 windows_path="$new_path"
21455 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21456 unix_path=`$CYGPATH -u "$windows_path"`
21457 new_path="$unix_path"
21458 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21459 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21460 new_path="$unix_path"
21461 fi
21462
21463 if test "x$path" != "x$new_path"; then
21464 BOOT_JDK="$new_path"
21465 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21466 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21467 fi
21468
21469 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21470 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21471
21472 else
21473 # We're on a unix platform. Hooray! :)
21474 path="$BOOT_JDK"
21475 has_space=`$ECHO "$path" | $GREP " "`
21476 if test "x$has_space" != x; then
21477 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21478 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21479 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21480 fi
21481
21482 # Use eval to expand a potential ~
21483 eval path="$path"
21484 if test ! -f "$path" && test ! -d "$path"; then
21485 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21486 fi
21487
21488 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21489 fi
21490 fi
21491
21492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21493 $as_echo_n "checking for Boot JDK... " >&6; }
21494 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21495 $as_echo "$BOOT_JDK" >&6; }
21496 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21497 $as_echo_n "checking Boot JDK version... " >&6; }
21498 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21499 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21500 $as_echo "$BOOT_JDK_VERSION" >&6; }
21501 fi # end check jdk version
21502 fi # end check javac
21503 fi # end check java
21504 fi # end check boot jdk found
21505 fi
21506
21507 fi
21508
21509
21510 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21511 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21512 # Do we have a bin/java?
21513 if test ! -x "$BOOT_JDK/bin/java"; then
21514 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21515 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21516 BOOT_JDK_FOUND=no
21517 else
21518 # Do we have a bin/javac?
21519 if test ! -x "$BOOT_JDK/bin/javac"; then
21520 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21521 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21522 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21523 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21524 BOOT_JDK_FOUND=no
21525 else
21526 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21527 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21528
21529 # Extra M4 quote needed to protect [] in grep expression.
21530 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21531 if test "x$FOUND_CORRECT_VERSION" = x; then
21532 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21533 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21534 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21535 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21536 BOOT_JDK_FOUND=no
21537 else
21538 # We're done! :-)
21539 BOOT_JDK_FOUND=yes
21540
21541 # Only process if variable expands to non-empty
21542
21543 if test "x$BOOT_JDK" != x; then
21544 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21545
21546 # Input might be given as Windows format, start by converting to
21547 # unix format.
21548 path="$BOOT_JDK"
21549 new_path=`$CYGPATH -u "$path"`
21550
21551 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21552 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21553 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21554 # "foo.exe" is OK but "foo" is an error.
21555 #
21556 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21557 # It is also a way to make sure we got the proper file name for the real test later on.
21558 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21559 if test "x$test_shortpath" = x; then
21560 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21561 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21562 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21563 fi
21564
21565 # Call helper function which possibly converts this using DOS-style short mode.
21566 # If so, the updated path is stored in $new_path.
21567
21568 input_path="$new_path"
21569 # Check if we need to convert this using DOS-style short mode. If the path
21570 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21571 # take no chances and rewrite it.
21572 # Note: m4 eats our [], so we need to use [ and ] instead.
21573 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21574 if test "x$has_forbidden_chars" != x; then
21575 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21576 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21577 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21578 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21579 # Going to short mode and back again did indeed matter. Since short mode is
21580 # case insensitive, let's make it lowercase to improve readability.
21581 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21582 # Now convert it back to Unix-style (cygpath)
21583 input_path=`$CYGPATH -u "$shortmode_path"`
21584 new_path="$input_path"
21585 fi
21586 fi
21587
21588 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21589 if test "x$test_cygdrive_prefix" = x; then
21590 # As a simple fix, exclude /usr/bin since it's not a real path.
21591 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21592 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21593 # a path prefixed by /cygdrive for fixpath to work.
21594 new_path="$CYGWIN_ROOT_PATH$input_path"
21595 fi
21596 fi
21597
21598
21599 if test "x$path" != "x$new_path"; then
21600 BOOT_JDK="$new_path"
21601 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21602 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21603 fi
21604
21605 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21606
21607 path="$BOOT_JDK"
21608 has_colon=`$ECHO $path | $GREP ^.:`
21609 new_path="$path"
21610 if test "x$has_colon" = x; then
21611 # Not in mixed or Windows style, start by that.
21612 new_path=`cmd //c echo $path`
21613 fi
21614
21615
21616 input_path="$new_path"
21617 # Check if we need to convert this using DOS-style short mode. If the path
21618 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21619 # take no chances and rewrite it.
21620 # Note: m4 eats our [], so we need to use [ and ] instead.
21621 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21622 if test "x$has_forbidden_chars" != x; then
21623 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21624 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21625 fi
21626
21627
21628 windows_path="$new_path"
21629 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21630 unix_path=`$CYGPATH -u "$windows_path"`
21631 new_path="$unix_path"
21632 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21633 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21634 new_path="$unix_path"
21635 fi
21636
21637 if test "x$path" != "x$new_path"; then
21638 BOOT_JDK="$new_path"
21639 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21640 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21641 fi
21642
21643 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21644 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21645
21646 else
21647 # We're on a unix platform. Hooray! :)
21648 path="$BOOT_JDK"
21649 has_space=`$ECHO "$path" | $GREP " "`
21650 if test "x$has_space" != x; then
21651 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21652 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21653 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21654 fi
21655
21656 # Use eval to expand a potential ~
21657 eval path="$path"
21658 if test ! -f "$path" && test ! -d "$path"; then
21659 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21660 fi
21661
21662 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21663 fi
21664 fi
21665
21666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21667 $as_echo_n "checking for Boot JDK... " >&6; }
21668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21669 $as_echo "$BOOT_JDK" >&6; }
21670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21671 $as_echo_n "checking Boot JDK version... " >&6; }
21672 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21673 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21674 $as_echo "$BOOT_JDK_VERSION" >&6; }
21675 fi # end check jdk version
21676 fi # end check javac
21677 fi # end check java
21678 fi # end check boot jdk found
21679 fi
21680
21681
21682 # Test: Is $JAVA_HOME set?
21683
21684 if test "x$BOOT_JDK_FOUND" = xno; then
21685 # Now execute the test
21686
21687 if test "x$JAVA_HOME" != x; then
21688 JAVA_HOME_PROCESSED="$JAVA_HOME"
21689
21690 # Only process if variable expands to non-empty
21691
21692 if test "x$JAVA_HOME_PROCESSED" != x; then
21693 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21694
21695 # Input might be given as Windows format, start by converting to
21696 # unix format.
21697 path="$JAVA_HOME_PROCESSED"
21698 new_path=`$CYGPATH -u "$path"`
21699
21700 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21701 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21702 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21703 # "foo.exe" is OK but "foo" is an error.
21704 #
21705 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21706 # It is also a way to make sure we got the proper file name for the real test later on.
21707 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21708 if test "x$test_shortpath" = x; then
21709 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21710 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21711 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
21712 fi
21713
21714 # Call helper function which possibly converts this using DOS-style short mode.
21715 # If so, the updated path is stored in $new_path.
21716
21717 input_path="$new_path"
21718 # Check if we need to convert this using DOS-style short mode. If the path
21719 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21720 # take no chances and rewrite it.
21721 # Note: m4 eats our [], so we need to use [ and ] instead.
21722 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21723 if test "x$has_forbidden_chars" != x; then
21724 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21725 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21726 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21727 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21728 # Going to short mode and back again did indeed matter. Since short mode is
21729 # case insensitive, let's make it lowercase to improve readability.
21730 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21731 # Now convert it back to Unix-style (cygpath)
21732 input_path=`$CYGPATH -u "$shortmode_path"`
21733 new_path="$input_path"
21734 fi
21735 fi
21736
21737 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21738 if test "x$test_cygdrive_prefix" = x; then
21739 # As a simple fix, exclude /usr/bin since it's not a real path.
21740 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21741 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21742 # a path prefixed by /cygdrive for fixpath to work.
21743 new_path="$CYGWIN_ROOT_PATH$input_path"
21744 fi
21745 fi
21746
21747
21748 if test "x$path" != "x$new_path"; then
21749 JAVA_HOME_PROCESSED="$new_path"
21750 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21751 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21752 fi
21753
21754 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21755
21756 path="$JAVA_HOME_PROCESSED"
21757 has_colon=`$ECHO $path | $GREP ^.:`
21758 new_path="$path"
21759 if test "x$has_colon" = x; then
21760 # Not in mixed or Windows style, start by that.
21761 new_path=`cmd //c echo $path`
21762 fi
21763
21764
21765 input_path="$new_path"
21766 # Check if we need to convert this using DOS-style short mode. If the path
21767 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21768 # take no chances and rewrite it.
21769 # Note: m4 eats our [], so we need to use [ and ] instead.
21770 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21771 if test "x$has_forbidden_chars" != x; then
21772 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21773 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21774 fi
21775
21776
21777 windows_path="$new_path"
21778 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21779 unix_path=`$CYGPATH -u "$windows_path"`
21780 new_path="$unix_path"
21781 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21782 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21783 new_path="$unix_path"
21784 fi
21785
21786 if test "x$path" != "x$new_path"; then
21787 JAVA_HOME_PROCESSED="$new_path"
21788 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21789 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21790 fi
21791
21792 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21793 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21794
21795 else
21796 # We're on a unix platform. Hooray! :)
21797 path="$JAVA_HOME_PROCESSED"
21798 has_space=`$ECHO "$path" | $GREP " "`
21799 if test "x$has_space" != x; then
21800 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21801 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21802 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21803 fi
21804
21805 # Use eval to expand a potential ~
21806 eval path="$path"
21807 if test ! -f "$path" && test ! -d "$path"; then
21808 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21809 fi
21810
21811 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21812 fi
21813 fi
21814
21815 if test ! -d "$JAVA_HOME_PROCESSED"; then
21816 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21817 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21818 else
21819 # Aha, the user has set a JAVA_HOME
21820 # let us use that as the Boot JDK.
21821 BOOT_JDK="$JAVA_HOME_PROCESSED"
21822 BOOT_JDK_FOUND=maybe
21823 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21824 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21825 fi
21826 fi
21827
21828
21829 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21830 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21831 # Do we have a bin/java?
21832 if test ! -x "$BOOT_JDK/bin/java"; then
21833 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21834 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21835 BOOT_JDK_FOUND=no
21836 else
21837 # Do we have a bin/javac?
21838 if test ! -x "$BOOT_JDK/bin/javac"; then
21839 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21840 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21841 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21842 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21843 BOOT_JDK_FOUND=no
21844 else
21845 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21846 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21847
21848 # Extra M4 quote needed to protect [] in grep expression.
21849 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21850 if test "x$FOUND_CORRECT_VERSION" = x; then
21851 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21852 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21853 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21854 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21855 BOOT_JDK_FOUND=no
21856 else
21857 # We're done! :-)
21858 BOOT_JDK_FOUND=yes
21859
21860 # Only process if variable expands to non-empty
21861
21862 if test "x$BOOT_JDK" != x; then
21863 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21864
21865 # Input might be given as Windows format, start by converting to
21866 # unix format.
21867 path="$BOOT_JDK"
21868 new_path=`$CYGPATH -u "$path"`
21869
21870 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21871 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21872 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21873 # "foo.exe" is OK but "foo" is an error.
21874 #
21875 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21876 # It is also a way to make sure we got the proper file name for the real test later on.
21877 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21878 if test "x$test_shortpath" = x; then
21879 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21880 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21881 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21882 fi
21883
21884 # Call helper function which possibly converts this using DOS-style short mode.
21885 # If so, the updated path is stored in $new_path.
21886
21887 input_path="$new_path"
21888 # Check if we need to convert this using DOS-style short mode. If the path
21889 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21890 # take no chances and rewrite it.
21891 # Note: m4 eats our [], so we need to use [ and ] instead.
21892 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21893 if test "x$has_forbidden_chars" != x; then
21894 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21895 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21896 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21897 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21898 # Going to short mode and back again did indeed matter. Since short mode is
21899 # case insensitive, let's make it lowercase to improve readability.
21900 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21901 # Now convert it back to Unix-style (cygpath)
21902 input_path=`$CYGPATH -u "$shortmode_path"`
21903 new_path="$input_path"
21904 fi
21905 fi
21906
21907 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21908 if test "x$test_cygdrive_prefix" = x; then
21909 # As a simple fix, exclude /usr/bin since it's not a real path.
21910 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21911 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21912 # a path prefixed by /cygdrive for fixpath to work.
21913 new_path="$CYGWIN_ROOT_PATH$input_path"
21914 fi
21915 fi
21916
21917
21918 if test "x$path" != "x$new_path"; then
21919 BOOT_JDK="$new_path"
21920 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21921 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21922 fi
21923
21924 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21925
21926 path="$BOOT_JDK"
21927 has_colon=`$ECHO $path | $GREP ^.:`
21928 new_path="$path"
21929 if test "x$has_colon" = x; then
21930 # Not in mixed or Windows style, start by that.
21931 new_path=`cmd //c echo $path`
21932 fi
21933
21934
21935 input_path="$new_path"
21936 # Check if we need to convert this using DOS-style short mode. If the path
21937 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21938 # take no chances and rewrite it.
21939 # Note: m4 eats our [], so we need to use [ and ] instead.
21940 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21941 if test "x$has_forbidden_chars" != x; then
21942 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21943 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21944 fi
21945
21946
21947 windows_path="$new_path"
21948 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21949 unix_path=`$CYGPATH -u "$windows_path"`
21950 new_path="$unix_path"
21951 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21952 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21953 new_path="$unix_path"
21954 fi
21955
21956 if test "x$path" != "x$new_path"; then
21957 BOOT_JDK="$new_path"
21958 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21959 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21960 fi
21961
21962 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21963 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21964
21965 else
21966 # We're on a unix platform. Hooray! :)
21967 path="$BOOT_JDK"
21968 has_space=`$ECHO "$path" | $GREP " "`
21969 if test "x$has_space" != x; then
21970 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21971 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21972 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21973 fi
21974
21975 # Use eval to expand a potential ~
21976 eval path="$path"
21977 if test ! -f "$path" && test ! -d "$path"; then
21978 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21979 fi
21980
21981 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21982 fi
21983 fi
21984
21985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21986 $as_echo_n "checking for Boot JDK... " >&6; }
21987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21988 $as_echo "$BOOT_JDK" >&6; }
21989 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21990 $as_echo_n "checking Boot JDK version... " >&6; }
21991 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21992 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21993 $as_echo "$BOOT_JDK_VERSION" >&6; }
21994 fi # end check jdk version
21995 fi # end check javac
21996 fi # end check java
21997 fi # end check boot jdk found
21998 fi
21999
22000
22001 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
22002
22003 if test "x$BOOT_JDK_FOUND" = xno; then
22004 # Now execute the test
22005
22006 # Extract the first word of "javac", so it can be a program name with args.
22007 set dummy javac; ac_word=$2
22008 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22009 $as_echo_n "checking for $ac_word... " >&6; }
22010 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
22011 $as_echo_n "(cached) " >&6
22012 else
22013 case $JAVAC_CHECK in
22014 [\\/]* | ?:[\\/]*)
22015 ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
22016 ;;
22017 *)
22018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22019 for as_dir in $PATH
22020 do
22021 IFS=$as_save_IFS
22022 test -z "$as_dir" && as_dir=.
22023 for ac_exec_ext in '' $ac_executable_extensions; do
22024 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22025 ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
22026 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22027 break 2
22028 fi
22029 done
22030 done
22031 IFS=$as_save_IFS
22032
22033 ;;
22034 esac
22035 fi
22036 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
22037 if test -n "$JAVAC_CHECK"; then
22038 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
22039 $as_echo "$JAVAC_CHECK" >&6; }
22040 else
22041 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22042 $as_echo "no" >&6; }
22043 fi
22044
22045
22046 # Extract the first word of "java", so it can be a program name with args.
22047 set dummy java; ac_word=$2
22048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22049 $as_echo_n "checking for $ac_word... " >&6; }
22050 if ${ac_cv_path_JAVA_CHECK+:} false; then :
22051 $as_echo_n "(cached) " >&6
22052 else
22053 case $JAVA_CHECK in
22054 [\\/]* | ?:[\\/]*)
22055 ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
22056 ;;
22057 *)
22058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22059 for as_dir in $PATH
22060 do
22061 IFS=$as_save_IFS
22062 test -z "$as_dir" && as_dir=.
22063 for ac_exec_ext in '' $ac_executable_extensions; do
22064 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22065 ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
22066 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22067 break 2
22068 fi
22069 done
22070 done
22071 IFS=$as_save_IFS
22072
22073 ;;
22074 esac
22075 fi
22076 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
22077 if test -n "$JAVA_CHECK"; then
22078 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
22079 $as_echo "$JAVA_CHECK" >&6; }
22080 else
22081 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22082 $as_echo "no" >&6; }
22083 fi
22084
22085
22086 BINARY="$JAVAC_CHECK"
22087 if test "x$JAVAC_CHECK" = x; then
22088 BINARY="$JAVA_CHECK"
22089 fi
22090 if test "x$BINARY" != x; then
22091 # So there is a java(c) binary, it might be part of a JDK.
22092 # Lets find the JDK/JRE directory by following symbolic links.
22093 # Linux/GNU systems often have links from /usr/bin/java to
22094 # /etc/alternatives/java to the real JDK binary.
22095
22096 if test "x$OPENJDK_BUILD_OS" != xwindows; then
22097 # Follow a chain of symbolic links. Use readlink
22098 # where it exists, else fall back to horribly
22099 # complicated shell code.
22100 if test "x$READLINK_TESTED" != yes; then
22101 # On MacOSX there is a readlink tool with a different
22102 # purpose than the GNU readlink tool. Check the found readlink.
22103 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
22104 if test "x$ISGNU" = x; then
22105 # A readlink that we do not know how to use.
22106 # Are there other non-GNU readlinks out there?
22107 READLINK_TESTED=yes
22108 READLINK=
22109 fi
22110 fi
22111
22112 if test "x$READLINK" != x; then
22113 BINARY=`$READLINK -f $BINARY`
22114 else
22115 # Save the current directory for restoring afterwards
22116 STARTDIR=$PWD
22117 COUNTER=0
22118 sym_link_dir=`$DIRNAME $BINARY`
22119 sym_link_file=`$BASENAME $BINARY`
22120 cd $sym_link_dir
22121 # Use -P flag to resolve symlinks in directories.
22122 cd `$THEPWDCMD -P`
22123 sym_link_dir=`$THEPWDCMD -P`
22124 # Resolve file symlinks
22125 while test $COUNTER -lt 20; do
22126 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
22127 if test "x$ISLINK" == x; then
22128 # This is not a symbolic link! We are done!
22129 break
22130 fi
22131 # Again resolve directory symlinks since the target of the just found
22132 # link could be in a different directory
22133 cd `$DIRNAME $ISLINK`
22134 sym_link_dir=`$THEPWDCMD -P`
22135 sym_link_file=`$BASENAME $ISLINK`
22136 let COUNTER=COUNTER+1
22137 done
22138 cd $STARTDIR
22139 BINARY=$sym_link_dir/$sym_link_file
22140 fi
22141 fi
22142
22143 BOOT_JDK=`dirname "$BINARY"`
22144 BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
22145 if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
22146 # Looks like we found ourselves an JDK
22147 BOOT_JDK_FOUND=maybe
22148 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
22149 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
22150 fi
22151 fi
22152
22153
22154 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22155 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22156 # Do we have a bin/java?
22157 if test ! -x "$BOOT_JDK/bin/java"; then
22158 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22159 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22160 BOOT_JDK_FOUND=no
22161 else
22162 # Do we have a bin/javac?
22163 if test ! -x "$BOOT_JDK/bin/javac"; then
22164 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22165 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22166 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22167 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22168 BOOT_JDK_FOUND=no
22169 else
22170 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22171 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22172
22173 # Extra M4 quote needed to protect [] in grep expression.
22174 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22175 if test "x$FOUND_CORRECT_VERSION" = x; then
22176 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22177 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22178 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22179 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22180 BOOT_JDK_FOUND=no
22181 else
22182 # We're done! :-)
22183 BOOT_JDK_FOUND=yes
22184
22185 # Only process if variable expands to non-empty
22186
22187 if test "x$BOOT_JDK" != x; then
22188 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22189
22190 # Input might be given as Windows format, start by converting to
22191 # unix format.
22192 path="$BOOT_JDK"
22193 new_path=`$CYGPATH -u "$path"`
22194
22195 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22196 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22197 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22198 # "foo.exe" is OK but "foo" is an error.
22199 #
22200 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22201 # It is also a way to make sure we got the proper file name for the real test later on.
22202 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22203 if test "x$test_shortpath" = x; then
22204 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22205 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22206 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22207 fi
22208
22209 # Call helper function which possibly converts this using DOS-style short mode.
22210 # If so, the updated path is stored in $new_path.
22211
22212 input_path="$new_path"
22213 # Check if we need to convert this using DOS-style short mode. If the path
22214 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22215 # take no chances and rewrite it.
22216 # Note: m4 eats our [], so we need to use [ and ] instead.
22217 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22218 if test "x$has_forbidden_chars" != x; then
22219 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22220 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22221 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22222 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22223 # Going to short mode and back again did indeed matter. Since short mode is
22224 # case insensitive, let's make it lowercase to improve readability.
22225 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22226 # Now convert it back to Unix-style (cygpath)
22227 input_path=`$CYGPATH -u "$shortmode_path"`
22228 new_path="$input_path"
22229 fi
22230 fi
22231
22232 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22233 if test "x$test_cygdrive_prefix" = x; then
22234 # As a simple fix, exclude /usr/bin since it's not a real path.
22235 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22236 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22237 # a path prefixed by /cygdrive for fixpath to work.
22238 new_path="$CYGWIN_ROOT_PATH$input_path"
22239 fi
22240 fi
22241
22242
22243 if test "x$path" != "x$new_path"; then
22244 BOOT_JDK="$new_path"
22245 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22246 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22247 fi
22248
22249 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22250
22251 path="$BOOT_JDK"
22252 has_colon=`$ECHO $path | $GREP ^.:`
22253 new_path="$path"
22254 if test "x$has_colon" = x; then
22255 # Not in mixed or Windows style, start by that.
22256 new_path=`cmd //c echo $path`
22257 fi
22258
22259
22260 input_path="$new_path"
22261 # Check if we need to convert this using DOS-style short mode. If the path
22262 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22263 # take no chances and rewrite it.
22264 # Note: m4 eats our [], so we need to use [ and ] instead.
22265 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22266 if test "x$has_forbidden_chars" != x; then
22267 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22268 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22269 fi
22270
22271
22272 windows_path="$new_path"
22273 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22274 unix_path=`$CYGPATH -u "$windows_path"`
22275 new_path="$unix_path"
22276 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22277 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22278 new_path="$unix_path"
22279 fi
22280
22281 if test "x$path" != "x$new_path"; then
22282 BOOT_JDK="$new_path"
22283 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22284 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22285 fi
22286
22287 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22288 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22289
22290 else
22291 # We're on a unix platform. Hooray! :)
22292 path="$BOOT_JDK"
22293 has_space=`$ECHO "$path" | $GREP " "`
22294 if test "x$has_space" != x; then
22295 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22296 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22297 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22298 fi
22299
22300 # Use eval to expand a potential ~
22301 eval path="$path"
22302 if test ! -f "$path" && test ! -d "$path"; then
22303 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22304 fi
22305
22306 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22307 fi
22308 fi
22309
22310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22311 $as_echo_n "checking for Boot JDK... " >&6; }
22312 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22313 $as_echo "$BOOT_JDK" >&6; }
22314 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22315 $as_echo_n "checking Boot JDK version... " >&6; }
22316 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22317 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22318 $as_echo "$BOOT_JDK_VERSION" >&6; }
22319 fi # end check jdk version
22320 fi # end check javac
22321 fi # end check java
22322 fi # end check boot jdk found
22323 fi
22324
22325
22326 # Test: Is there a JDK installed in default, well-known locations?
22327
22328 if test "x$BOOT_JDK_FOUND" = xno; then
22329 # Now execute the test
22330
22331 if test "x$OPENJDK_TARGET_OS" = xwindows; then
22332
22333 if test "x$BOOT_JDK_FOUND" = xno; then
22334 # Now execute the test
22335
22336 if test "x$ProgramW6432" != x; then
22337 VIRTUAL_DIR="$ProgramW6432/Java"
22338
22339 windows_path="$VIRTUAL_DIR"
22340 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22341 unix_path=`$CYGPATH -u "$windows_path"`
22342 VIRTUAL_DIR="$unix_path"
22343 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22344 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22345 VIRTUAL_DIR="$unix_path"
22346 fi
22347
22348
22349 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22350 BOOT_JDK_SUFFIX=""
22351 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22352 if test "x$ALL_JDKS_FOUND" != x; then
22353 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22354
22355 if test "x$BOOT_JDK_FOUND" = xno; then
22356 # Now execute the test
22357
22358 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22359 if test -d "$BOOT_JDK"; then
22360 BOOT_JDK_FOUND=maybe
22361 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22362 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22363 fi
22364
22365
22366 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22367 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22368 # Do we have a bin/java?
22369 if test ! -x "$BOOT_JDK/bin/java"; then
22370 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22371 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22372 BOOT_JDK_FOUND=no
22373 else
22374 # Do we have a bin/javac?
22375 if test ! -x "$BOOT_JDK/bin/javac"; then
22376 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22377 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22378 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22379 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22380 BOOT_JDK_FOUND=no
22381 else
22382 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22383 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22384
22385 # Extra M4 quote needed to protect [] in grep expression.
22386 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22387 if test "x$FOUND_CORRECT_VERSION" = x; then
22388 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22389 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22390 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22391 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22392 BOOT_JDK_FOUND=no
22393 else
22394 # We're done! :-)
22395 BOOT_JDK_FOUND=yes
22396
22397 # Only process if variable expands to non-empty
22398
22399 if test "x$BOOT_JDK" != x; then
22400 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22401
22402 # Input might be given as Windows format, start by converting to
22403 # unix format.
22404 path="$BOOT_JDK"
22405 new_path=`$CYGPATH -u "$path"`
22406
22407 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22408 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22409 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22410 # "foo.exe" is OK but "foo" is an error.
22411 #
22412 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22413 # It is also a way to make sure we got the proper file name for the real test later on.
22414 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22415 if test "x$test_shortpath" = x; then
22416 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22417 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22418 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22419 fi
22420
22421 # Call helper function which possibly converts this using DOS-style short mode.
22422 # If so, the updated path is stored in $new_path.
22423
22424 input_path="$new_path"
22425 # Check if we need to convert this using DOS-style short mode. If the path
22426 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22427 # take no chances and rewrite it.
22428 # Note: m4 eats our [], so we need to use [ and ] instead.
22429 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22430 if test "x$has_forbidden_chars" != x; then
22431 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22432 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22433 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22434 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22435 # Going to short mode and back again did indeed matter. Since short mode is
22436 # case insensitive, let's make it lowercase to improve readability.
22437 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22438 # Now convert it back to Unix-style (cygpath)
22439 input_path=`$CYGPATH -u "$shortmode_path"`
22440 new_path="$input_path"
22441 fi
22442 fi
22443
22444 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22445 if test "x$test_cygdrive_prefix" = x; then
22446 # As a simple fix, exclude /usr/bin since it's not a real path.
22447 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22448 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22449 # a path prefixed by /cygdrive for fixpath to work.
22450 new_path="$CYGWIN_ROOT_PATH$input_path"
22451 fi
22452 fi
22453
22454
22455 if test "x$path" != "x$new_path"; then
22456 BOOT_JDK="$new_path"
22457 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22458 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22459 fi
22460
22461 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22462
22463 path="$BOOT_JDK"
22464 has_colon=`$ECHO $path | $GREP ^.:`
22465 new_path="$path"
22466 if test "x$has_colon" = x; then
22467 # Not in mixed or Windows style, start by that.
22468 new_path=`cmd //c echo $path`
22469 fi
22470
22471
22472 input_path="$new_path"
22473 # Check if we need to convert this using DOS-style short mode. If the path
22474 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22475 # take no chances and rewrite it.
22476 # Note: m4 eats our [], so we need to use [ and ] instead.
22477 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22478 if test "x$has_forbidden_chars" != x; then
22479 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22480 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22481 fi
22482
22483
22484 windows_path="$new_path"
22485 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22486 unix_path=`$CYGPATH -u "$windows_path"`
22487 new_path="$unix_path"
22488 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22489 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22490 new_path="$unix_path"
22491 fi
22492
22493 if test "x$path" != "x$new_path"; then
22494 BOOT_JDK="$new_path"
22495 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22496 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22497 fi
22498
22499 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22500 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22501
22502 else
22503 # We're on a unix platform. Hooray! :)
22504 path="$BOOT_JDK"
22505 has_space=`$ECHO "$path" | $GREP " "`
22506 if test "x$has_space" != x; then
22507 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22508 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22509 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22510 fi
22511
22512 # Use eval to expand a potential ~
22513 eval path="$path"
22514 if test ! -f "$path" && test ! -d "$path"; then
22515 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22516 fi
22517
22518 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22519 fi
22520 fi
22521
22522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22523 $as_echo_n "checking for Boot JDK... " >&6; }
22524 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22525 $as_echo "$BOOT_JDK" >&6; }
22526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22527 $as_echo_n "checking Boot JDK version... " >&6; }
22528 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22529 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22530 $as_echo "$BOOT_JDK_VERSION" >&6; }
22531 fi # end check jdk version
22532 fi # end check javac
22533 fi # end check java
22534 fi # end check boot jdk found
22535 fi
22536
22537 done
22538 fi
22539
22540 fi
22541
22542
22543 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22544 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22545 # Do we have a bin/java?
22546 if test ! -x "$BOOT_JDK/bin/java"; then
22547 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22548 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22549 BOOT_JDK_FOUND=no
22550 else
22551 # Do we have a bin/javac?
22552 if test ! -x "$BOOT_JDK/bin/javac"; then
22553 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22554 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22555 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22556 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22557 BOOT_JDK_FOUND=no
22558 else
22559 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22560 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22561
22562 # Extra M4 quote needed to protect [] in grep expression.
22563 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22564 if test "x$FOUND_CORRECT_VERSION" = x; then
22565 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22566 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22567 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22568 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22569 BOOT_JDK_FOUND=no
22570 else
22571 # We're done! :-)
22572 BOOT_JDK_FOUND=yes
22573
22574 # Only process if variable expands to non-empty
22575
22576 if test "x$BOOT_JDK" != x; then
22577 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22578
22579 # Input might be given as Windows format, start by converting to
22580 # unix format.
22581 path="$BOOT_JDK"
22582 new_path=`$CYGPATH -u "$path"`
22583
22584 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22585 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22586 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22587 # "foo.exe" is OK but "foo" is an error.
22588 #
22589 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22590 # It is also a way to make sure we got the proper file name for the real test later on.
22591 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22592 if test "x$test_shortpath" = x; then
22593 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22594 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22595 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22596 fi
22597
22598 # Call helper function which possibly converts this using DOS-style short mode.
22599 # If so, the updated path is stored in $new_path.
22600
22601 input_path="$new_path"
22602 # Check if we need to convert this using DOS-style short mode. If the path
22603 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22604 # take no chances and rewrite it.
22605 # Note: m4 eats our [], so we need to use [ and ] instead.
22606 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22607 if test "x$has_forbidden_chars" != x; then
22608 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22609 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22610 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22611 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22612 # Going to short mode and back again did indeed matter. Since short mode is
22613 # case insensitive, let's make it lowercase to improve readability.
22614 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22615 # Now convert it back to Unix-style (cygpath)
22616 input_path=`$CYGPATH -u "$shortmode_path"`
22617 new_path="$input_path"
22618 fi
22619 fi
22620
22621 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22622 if test "x$test_cygdrive_prefix" = x; then
22623 # As a simple fix, exclude /usr/bin since it's not a real path.
22624 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22625 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22626 # a path prefixed by /cygdrive for fixpath to work.
22627 new_path="$CYGWIN_ROOT_PATH$input_path"
22628 fi
22629 fi
22630
22631
22632 if test "x$path" != "x$new_path"; then
22633 BOOT_JDK="$new_path"
22634 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22635 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22636 fi
22637
22638 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22639
22640 path="$BOOT_JDK"
22641 has_colon=`$ECHO $path | $GREP ^.:`
22642 new_path="$path"
22643 if test "x$has_colon" = x; then
22644 # Not in mixed or Windows style, start by that.
22645 new_path=`cmd //c echo $path`
22646 fi
22647
22648
22649 input_path="$new_path"
22650 # Check if we need to convert this using DOS-style short mode. If the path
22651 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22652 # take no chances and rewrite it.
22653 # Note: m4 eats our [], so we need to use [ and ] instead.
22654 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22655 if test "x$has_forbidden_chars" != x; then
22656 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22657 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22658 fi
22659
22660
22661 windows_path="$new_path"
22662 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22663 unix_path=`$CYGPATH -u "$windows_path"`
22664 new_path="$unix_path"
22665 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22666 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22667 new_path="$unix_path"
22668 fi
22669
22670 if test "x$path" != "x$new_path"; then
22671 BOOT_JDK="$new_path"
22672 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22673 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22674 fi
22675
22676 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22677 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22678
22679 else
22680 # We're on a unix platform. Hooray! :)
22681 path="$BOOT_JDK"
22682 has_space=`$ECHO "$path" | $GREP " "`
22683 if test "x$has_space" != x; then
22684 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22685 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22686 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22687 fi
22688
22689 # Use eval to expand a potential ~
22690 eval path="$path"
22691 if test ! -f "$path" && test ! -d "$path"; then
22692 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22693 fi
22694
22695 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22696 fi
22697 fi
22698
22699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22700 $as_echo_n "checking for Boot JDK... " >&6; }
22701 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22702 $as_echo "$BOOT_JDK" >&6; }
22703 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22704 $as_echo_n "checking Boot JDK version... " >&6; }
22705 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22707 $as_echo "$BOOT_JDK_VERSION" >&6; }
22708 fi # end check jdk version
22709 fi # end check javac
22710 fi # end check java
22711 fi # end check boot jdk found
22712 fi
22713
22714
22715 if test "x$BOOT_JDK_FOUND" = xno; then
22716 # Now execute the test
22717
22718 if test "x$PROGRAMW6432" != x; then
22719 VIRTUAL_DIR="$PROGRAMW6432/Java"
22720
22721 windows_path="$VIRTUAL_DIR"
22722 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22723 unix_path=`$CYGPATH -u "$windows_path"`
22724 VIRTUAL_DIR="$unix_path"
22725 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22726 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22727 VIRTUAL_DIR="$unix_path"
22728 fi
22729
22730
22731 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22732 BOOT_JDK_SUFFIX=""
22733 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22734 if test "x$ALL_JDKS_FOUND" != x; then
22735 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22736
22737 if test "x$BOOT_JDK_FOUND" = xno; then
22738 # Now execute the test
22739
22740 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22741 if test -d "$BOOT_JDK"; then
22742 BOOT_JDK_FOUND=maybe
22743 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22744 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22745 fi
22746
22747
22748 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22749 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22750 # Do we have a bin/java?
22751 if test ! -x "$BOOT_JDK/bin/java"; then
22752 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22753 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22754 BOOT_JDK_FOUND=no
22755 else
22756 # Do we have a bin/javac?
22757 if test ! -x "$BOOT_JDK/bin/javac"; then
22758 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22760 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22761 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22762 BOOT_JDK_FOUND=no
22763 else
22764 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22765 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22766
22767 # Extra M4 quote needed to protect [] in grep expression.
22768 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22769 if test "x$FOUND_CORRECT_VERSION" = x; then
22770 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22771 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22772 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22773 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22774 BOOT_JDK_FOUND=no
22775 else
22776 # We're done! :-)
22777 BOOT_JDK_FOUND=yes
22778
22779 # Only process if variable expands to non-empty
22780
22781 if test "x$BOOT_JDK" != x; then
22782 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22783
22784 # Input might be given as Windows format, start by converting to
22785 # unix format.
22786 path="$BOOT_JDK"
22787 new_path=`$CYGPATH -u "$path"`
22788
22789 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22790 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22791 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22792 # "foo.exe" is OK but "foo" is an error.
22793 #
22794 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22795 # It is also a way to make sure we got the proper file name for the real test later on.
22796 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22797 if test "x$test_shortpath" = x; then
22798 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22799 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22800 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22801 fi
22802
22803 # Call helper function which possibly converts this using DOS-style short mode.
22804 # If so, the updated path is stored in $new_path.
22805
22806 input_path="$new_path"
22807 # Check if we need to convert this using DOS-style short mode. If the path
22808 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22809 # take no chances and rewrite it.
22810 # Note: m4 eats our [], so we need to use [ and ] instead.
22811 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22812 if test "x$has_forbidden_chars" != x; then
22813 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22814 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22815 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22816 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22817 # Going to short mode and back again did indeed matter. Since short mode is
22818 # case insensitive, let's make it lowercase to improve readability.
22819 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22820 # Now convert it back to Unix-style (cygpath)
22821 input_path=`$CYGPATH -u "$shortmode_path"`
22822 new_path="$input_path"
22823 fi
22824 fi
22825
22826 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22827 if test "x$test_cygdrive_prefix" = x; then
22828 # As a simple fix, exclude /usr/bin since it's not a real path.
22829 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22830 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22831 # a path prefixed by /cygdrive for fixpath to work.
22832 new_path="$CYGWIN_ROOT_PATH$input_path"
22833 fi
22834 fi
22835
22836
22837 if test "x$path" != "x$new_path"; then
22838 BOOT_JDK="$new_path"
22839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22840 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22841 fi
22842
22843 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22844
22845 path="$BOOT_JDK"
22846 has_colon=`$ECHO $path | $GREP ^.:`
22847 new_path="$path"
22848 if test "x$has_colon" = x; then
22849 # Not in mixed or Windows style, start by that.
22850 new_path=`cmd //c echo $path`
22851 fi
22852
22853
22854 input_path="$new_path"
22855 # Check if we need to convert this using DOS-style short mode. If the path
22856 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22857 # take no chances and rewrite it.
22858 # Note: m4 eats our [], so we need to use [ and ] instead.
22859 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22860 if test "x$has_forbidden_chars" != x; then
22861 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22862 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22863 fi
22864
22865
22866 windows_path="$new_path"
22867 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22868 unix_path=`$CYGPATH -u "$windows_path"`
22869 new_path="$unix_path"
22870 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22871 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22872 new_path="$unix_path"
22873 fi
22874
22875 if test "x$path" != "x$new_path"; then
22876 BOOT_JDK="$new_path"
22877 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22878 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22879 fi
22880
22881 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22882 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22883
22884 else
22885 # We're on a unix platform. Hooray! :)
22886 path="$BOOT_JDK"
22887 has_space=`$ECHO "$path" | $GREP " "`
22888 if test "x$has_space" != x; then
22889 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22890 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22891 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22892 fi
22893
22894 # Use eval to expand a potential ~
22895 eval path="$path"
22896 if test ! -f "$path" && test ! -d "$path"; then
22897 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22898 fi
22899
22900 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22901 fi
22902 fi
22903
22904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22905 $as_echo_n "checking for Boot JDK... " >&6; }
22906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22907 $as_echo "$BOOT_JDK" >&6; }
22908 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22909 $as_echo_n "checking Boot JDK version... " >&6; }
22910 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22912 $as_echo "$BOOT_JDK_VERSION" >&6; }
22913 fi # end check jdk version
22914 fi # end check javac
22915 fi # end check java
22916 fi # end check boot jdk found
22917 fi
22918
22919 done
22920 fi
22921
22922 fi
22923
22924
22925 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22926 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22927 # Do we have a bin/java?
22928 if test ! -x "$BOOT_JDK/bin/java"; then
22929 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22930 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22931 BOOT_JDK_FOUND=no
22932 else
22933 # Do we have a bin/javac?
22934 if test ! -x "$BOOT_JDK/bin/javac"; then
22935 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22936 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22937 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22938 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22939 BOOT_JDK_FOUND=no
22940 else
22941 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22942 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22943
22944 # Extra M4 quote needed to protect [] in grep expression.
22945 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22946 if test "x$FOUND_CORRECT_VERSION" = x; then
22947 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22948 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22949 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22950 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22951 BOOT_JDK_FOUND=no
22952 else
22953 # We're done! :-)
22954 BOOT_JDK_FOUND=yes
22955
22956 # Only process if variable expands to non-empty
22957
22958 if test "x$BOOT_JDK" != x; then
22959 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22960
22961 # Input might be given as Windows format, start by converting to
22962 # unix format.
22963 path="$BOOT_JDK"
22964 new_path=`$CYGPATH -u "$path"`
22965
22966 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22967 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22968 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22969 # "foo.exe" is OK but "foo" is an error.
22970 #
22971 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22972 # It is also a way to make sure we got the proper file name for the real test later on.
22973 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22974 if test "x$test_shortpath" = x; then
22975 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22976 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22977 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22978 fi
22979
22980 # Call helper function which possibly converts this using DOS-style short mode.
22981 # If so, the updated path is stored in $new_path.
22982
22983 input_path="$new_path"
22984 # Check if we need to convert this using DOS-style short mode. If the path
22985 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22986 # take no chances and rewrite it.
22987 # Note: m4 eats our [], so we need to use [ and ] instead.
22988 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22989 if test "x$has_forbidden_chars" != x; then
22990 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22991 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22992 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22993 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22994 # Going to short mode and back again did indeed matter. Since short mode is
22995 # case insensitive, let's make it lowercase to improve readability.
22996 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22997 # Now convert it back to Unix-style (cygpath)
22998 input_path=`$CYGPATH -u "$shortmode_path"`
22999 new_path="$input_path"
23000 fi
23001 fi
23002
23003 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23004 if test "x$test_cygdrive_prefix" = x; then
23005 # As a simple fix, exclude /usr/bin since it's not a real path.
23006 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23007 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23008 # a path prefixed by /cygdrive for fixpath to work.
23009 new_path="$CYGWIN_ROOT_PATH$input_path"
23010 fi
23011 fi
23012
23013
23014 if test "x$path" != "x$new_path"; then
23015 BOOT_JDK="$new_path"
23016 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23017 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23018 fi
23019
23020 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23021
23022 path="$BOOT_JDK"
23023 has_colon=`$ECHO $path | $GREP ^.:`
23024 new_path="$path"
23025 if test "x$has_colon" = x; then
23026 # Not in mixed or Windows style, start by that.
23027 new_path=`cmd //c echo $path`
23028 fi
23029
23030
23031 input_path="$new_path"
23032 # Check if we need to convert this using DOS-style short mode. If the path
23033 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23034 # take no chances and rewrite it.
23035 # Note: m4 eats our [], so we need to use [ and ] instead.
23036 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23037 if test "x$has_forbidden_chars" != x; then
23038 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23039 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23040 fi
23041
23042
23043 windows_path="$new_path"
23044 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23045 unix_path=`$CYGPATH -u "$windows_path"`
23046 new_path="$unix_path"
23047 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23048 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23049 new_path="$unix_path"
23050 fi
23051
23052 if test "x$path" != "x$new_path"; then
23053 BOOT_JDK="$new_path"
23054 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23055 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23056 fi
23057
23058 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23059 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23060
23061 else
23062 # We're on a unix platform. Hooray! :)
23063 path="$BOOT_JDK"
23064 has_space=`$ECHO "$path" | $GREP " "`
23065 if test "x$has_space" != x; then
23066 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23067 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23068 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23069 fi
23070
23071 # Use eval to expand a potential ~
23072 eval path="$path"
23073 if test ! -f "$path" && test ! -d "$path"; then
23074 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23075 fi
23076
23077 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23078 fi
23079 fi
23080
23081 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23082 $as_echo_n "checking for Boot JDK... " >&6; }
23083 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23084 $as_echo "$BOOT_JDK" >&6; }
23085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23086 $as_echo_n "checking Boot JDK version... " >&6; }
23087 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23088 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23089 $as_echo "$BOOT_JDK_VERSION" >&6; }
23090 fi # end check jdk version
23091 fi # end check javac
23092 fi # end check java
23093 fi # end check boot jdk found
23094 fi
23095
23096
23097 if test "x$BOOT_JDK_FOUND" = xno; then
23098 # Now execute the test
23099
23100 if test "x$PROGRAMFILES" != x; then
23101 VIRTUAL_DIR="$PROGRAMFILES/Java"
23102
23103 windows_path="$VIRTUAL_DIR"
23104 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23105 unix_path=`$CYGPATH -u "$windows_path"`
23106 VIRTUAL_DIR="$unix_path"
23107 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23108 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23109 VIRTUAL_DIR="$unix_path"
23110 fi
23111
23112
23113 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23114 BOOT_JDK_SUFFIX=""
23115 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23116 if test "x$ALL_JDKS_FOUND" != x; then
23117 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23118
23119 if test "x$BOOT_JDK_FOUND" = xno; then
23120 # Now execute the test
23121
23122 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23123 if test -d "$BOOT_JDK"; then
23124 BOOT_JDK_FOUND=maybe
23125 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23126 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23127 fi
23128
23129
23130 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23131 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23132 # Do we have a bin/java?
23133 if test ! -x "$BOOT_JDK/bin/java"; then
23134 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23135 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23136 BOOT_JDK_FOUND=no
23137 else
23138 # Do we have a bin/javac?
23139 if test ! -x "$BOOT_JDK/bin/javac"; then
23140 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23141 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23142 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23143 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23144 BOOT_JDK_FOUND=no
23145 else
23146 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23147 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23148
23149 # Extra M4 quote needed to protect [] in grep expression.
23150 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23151 if test "x$FOUND_CORRECT_VERSION" = x; then
23152 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23153 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23154 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23155 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23156 BOOT_JDK_FOUND=no
23157 else
23158 # We're done! :-)
23159 BOOT_JDK_FOUND=yes
23160
23161 # Only process if variable expands to non-empty
23162
23163 if test "x$BOOT_JDK" != x; then
23164 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23165
23166 # Input might be given as Windows format, start by converting to
23167 # unix format.
23168 path="$BOOT_JDK"
23169 new_path=`$CYGPATH -u "$path"`
23170
23171 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23172 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23173 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23174 # "foo.exe" is OK but "foo" is an error.
23175 #
23176 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23177 # It is also a way to make sure we got the proper file name for the real test later on.
23178 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23179 if test "x$test_shortpath" = x; then
23180 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23181 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23182 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23183 fi
23184
23185 # Call helper function which possibly converts this using DOS-style short mode.
23186 # If so, the updated path is stored in $new_path.
23187
23188 input_path="$new_path"
23189 # Check if we need to convert this using DOS-style short mode. If the path
23190 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23191 # take no chances and rewrite it.
23192 # Note: m4 eats our [], so we need to use [ and ] instead.
23193 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23194 if test "x$has_forbidden_chars" != x; then
23195 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23196 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23197 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23198 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23199 # Going to short mode and back again did indeed matter. Since short mode is
23200 # case insensitive, let's make it lowercase to improve readability.
23201 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23202 # Now convert it back to Unix-style (cygpath)
23203 input_path=`$CYGPATH -u "$shortmode_path"`
23204 new_path="$input_path"
23205 fi
23206 fi
23207
23208 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23209 if test "x$test_cygdrive_prefix" = x; then
23210 # As a simple fix, exclude /usr/bin since it's not a real path.
23211 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23212 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23213 # a path prefixed by /cygdrive for fixpath to work.
23214 new_path="$CYGWIN_ROOT_PATH$input_path"
23215 fi
23216 fi
23217
23218
23219 if test "x$path" != "x$new_path"; then
23220 BOOT_JDK="$new_path"
23221 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23222 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23223 fi
23224
23225 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23226
23227 path="$BOOT_JDK"
23228 has_colon=`$ECHO $path | $GREP ^.:`
23229 new_path="$path"
23230 if test "x$has_colon" = x; then
23231 # Not in mixed or Windows style, start by that.
23232 new_path=`cmd //c echo $path`
23233 fi
23234
23235
23236 input_path="$new_path"
23237 # Check if we need to convert this using DOS-style short mode. If the path
23238 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23239 # take no chances and rewrite it.
23240 # Note: m4 eats our [], so we need to use [ and ] instead.
23241 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23242 if test "x$has_forbidden_chars" != x; then
23243 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23244 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23245 fi
23246
23247
23248 windows_path="$new_path"
23249 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23250 unix_path=`$CYGPATH -u "$windows_path"`
23251 new_path="$unix_path"
23252 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23253 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23254 new_path="$unix_path"
23255 fi
23256
23257 if test "x$path" != "x$new_path"; then
23258 BOOT_JDK="$new_path"
23259 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23260 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23261 fi
23262
23263 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23264 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23265
23266 else
23267 # We're on a unix platform. Hooray! :)
23268 path="$BOOT_JDK"
23269 has_space=`$ECHO "$path" | $GREP " "`
23270 if test "x$has_space" != x; then
23271 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23272 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23273 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23274 fi
23275
23276 # Use eval to expand a potential ~
23277 eval path="$path"
23278 if test ! -f "$path" && test ! -d "$path"; then
23279 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23280 fi
23281
23282 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23283 fi
23284 fi
23285
23286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23287 $as_echo_n "checking for Boot JDK... " >&6; }
23288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23289 $as_echo "$BOOT_JDK" >&6; }
23290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23291 $as_echo_n "checking Boot JDK version... " >&6; }
23292 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23293 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23294 $as_echo "$BOOT_JDK_VERSION" >&6; }
23295 fi # end check jdk version
23296 fi # end check javac
23297 fi # end check java
23298 fi # end check boot jdk found
23299 fi
23300
23301 done
23302 fi
23303
23304 fi
23305
23306
23307 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23308 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23309 # Do we have a bin/java?
23310 if test ! -x "$BOOT_JDK/bin/java"; then
23311 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23312 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23313 BOOT_JDK_FOUND=no
23314 else
23315 # Do we have a bin/javac?
23316 if test ! -x "$BOOT_JDK/bin/javac"; then
23317 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23318 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23319 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23320 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23321 BOOT_JDK_FOUND=no
23322 else
23323 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23324 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23325
23326 # Extra M4 quote needed to protect [] in grep expression.
23327 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23328 if test "x$FOUND_CORRECT_VERSION" = x; then
23329 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23330 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23331 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23332 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23333 BOOT_JDK_FOUND=no
23334 else
23335 # We're done! :-)
23336 BOOT_JDK_FOUND=yes
23337
23338 # Only process if variable expands to non-empty
23339
23340 if test "x$BOOT_JDK" != x; then
23341 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23342
23343 # Input might be given as Windows format, start by converting to
23344 # unix format.
23345 path="$BOOT_JDK"
23346 new_path=`$CYGPATH -u "$path"`
23347
23348 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23349 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23350 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23351 # "foo.exe" is OK but "foo" is an error.
23352 #
23353 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23354 # It is also a way to make sure we got the proper file name for the real test later on.
23355 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23356 if test "x$test_shortpath" = x; then
23357 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23358 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23359 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23360 fi
23361
23362 # Call helper function which possibly converts this using DOS-style short mode.
23363 # If so, the updated path is stored in $new_path.
23364
23365 input_path="$new_path"
23366 # Check if we need to convert this using DOS-style short mode. If the path
23367 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23368 # take no chances and rewrite it.
23369 # Note: m4 eats our [], so we need to use [ and ] instead.
23370 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23371 if test "x$has_forbidden_chars" != x; then
23372 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23373 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23374 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23375 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23376 # Going to short mode and back again did indeed matter. Since short mode is
23377 # case insensitive, let's make it lowercase to improve readability.
23378 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23379 # Now convert it back to Unix-style (cygpath)
23380 input_path=`$CYGPATH -u "$shortmode_path"`
23381 new_path="$input_path"
23382 fi
23383 fi
23384
23385 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23386 if test "x$test_cygdrive_prefix" = x; then
23387 # As a simple fix, exclude /usr/bin since it's not a real path.
23388 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23389 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23390 # a path prefixed by /cygdrive for fixpath to work.
23391 new_path="$CYGWIN_ROOT_PATH$input_path"
23392 fi
23393 fi
23394
23395
23396 if test "x$path" != "x$new_path"; then
23397 BOOT_JDK="$new_path"
23398 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23399 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23400 fi
23401
23402 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23403
23404 path="$BOOT_JDK"
23405 has_colon=`$ECHO $path | $GREP ^.:`
23406 new_path="$path"
23407 if test "x$has_colon" = x; then
23408 # Not in mixed or Windows style, start by that.
23409 new_path=`cmd //c echo $path`
23410 fi
23411
23412
23413 input_path="$new_path"
23414 # Check if we need to convert this using DOS-style short mode. If the path
23415 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23416 # take no chances and rewrite it.
23417 # Note: m4 eats our [], so we need to use [ and ] instead.
23418 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23419 if test "x$has_forbidden_chars" != x; then
23420 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23421 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23422 fi
23423
23424
23425 windows_path="$new_path"
23426 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23427 unix_path=`$CYGPATH -u "$windows_path"`
23428 new_path="$unix_path"
23429 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23430 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23431 new_path="$unix_path"
23432 fi
23433
23434 if test "x$path" != "x$new_path"; then
23435 BOOT_JDK="$new_path"
23436 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23437 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23438 fi
23439
23440 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23441 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23442
23443 else
23444 # We're on a unix platform. Hooray! :)
23445 path="$BOOT_JDK"
23446 has_space=`$ECHO "$path" | $GREP " "`
23447 if test "x$has_space" != x; then
23448 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23449 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23450 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23451 fi
23452
23453 # Use eval to expand a potential ~
23454 eval path="$path"
23455 if test ! -f "$path" && test ! -d "$path"; then
23456 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23457 fi
23458
23459 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23460 fi
23461 fi
23462
23463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23464 $as_echo_n "checking for Boot JDK... " >&6; }
23465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23466 $as_echo "$BOOT_JDK" >&6; }
23467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23468 $as_echo_n "checking Boot JDK version... " >&6; }
23469 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23470 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23471 $as_echo "$BOOT_JDK_VERSION" >&6; }
23472 fi # end check jdk version
23473 fi # end check javac
23474 fi # end check java
23475 fi # end check boot jdk found
23476 fi
23477
23478
23479 if test "x$BOOT_JDK_FOUND" = xno; then
23480 # Now execute the test
23481
23482 if test "x$ProgramFiles" != x; then
23483 VIRTUAL_DIR="$ProgramFiles/Java"
23484
23485 windows_path="$VIRTUAL_DIR"
23486 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23487 unix_path=`$CYGPATH -u "$windows_path"`
23488 VIRTUAL_DIR="$unix_path"
23489 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23490 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23491 VIRTUAL_DIR="$unix_path"
23492 fi
23493
23494
23495 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23496 BOOT_JDK_SUFFIX=""
23497 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23498 if test "x$ALL_JDKS_FOUND" != x; then
23499 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23500
23501 if test "x$BOOT_JDK_FOUND" = xno; then
23502 # Now execute the test
23503
23504 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23505 if test -d "$BOOT_JDK"; then
23506 BOOT_JDK_FOUND=maybe
23507 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23508 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23509 fi
23510
23511
23512 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23513 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23514 # Do we have a bin/java?
23515 if test ! -x "$BOOT_JDK/bin/java"; then
23516 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23517 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23518 BOOT_JDK_FOUND=no
23519 else
23520 # Do we have a bin/javac?
23521 if test ! -x "$BOOT_JDK/bin/javac"; then
23522 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23523 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23524 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23525 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23526 BOOT_JDK_FOUND=no
23527 else
23528 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23529 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23530
23531 # Extra M4 quote needed to protect [] in grep expression.
23532 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23533 if test "x$FOUND_CORRECT_VERSION" = x; then
23534 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23535 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23536 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23537 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23538 BOOT_JDK_FOUND=no
23539 else
23540 # We're done! :-)
23541 BOOT_JDK_FOUND=yes
23542
23543 # Only process if variable expands to non-empty
23544
23545 if test "x$BOOT_JDK" != x; then
23546 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23547
23548 # Input might be given as Windows format, start by converting to
23549 # unix format.
23550 path="$BOOT_JDK"
23551 new_path=`$CYGPATH -u "$path"`
23552
23553 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23554 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23555 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23556 # "foo.exe" is OK but "foo" is an error.
23557 #
23558 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23559 # It is also a way to make sure we got the proper file name for the real test later on.
23560 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23561 if test "x$test_shortpath" = x; then
23562 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23563 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23564 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23565 fi
23566
23567 # Call helper function which possibly converts this using DOS-style short mode.
23568 # If so, the updated path is stored in $new_path.
23569
23570 input_path="$new_path"
23571 # Check if we need to convert this using DOS-style short mode. If the path
23572 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23573 # take no chances and rewrite it.
23574 # Note: m4 eats our [], so we need to use [ and ] instead.
23575 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23576 if test "x$has_forbidden_chars" != x; then
23577 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23578 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23579 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23580 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23581 # Going to short mode and back again did indeed matter. Since short mode is
23582 # case insensitive, let's make it lowercase to improve readability.
23583 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23584 # Now convert it back to Unix-style (cygpath)
23585 input_path=`$CYGPATH -u "$shortmode_path"`
23586 new_path="$input_path"
23587 fi
23588 fi
23589
23590 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23591 if test "x$test_cygdrive_prefix" = x; then
23592 # As a simple fix, exclude /usr/bin since it's not a real path.
23593 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23594 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23595 # a path prefixed by /cygdrive for fixpath to work.
23596 new_path="$CYGWIN_ROOT_PATH$input_path"
23597 fi
23598 fi
23599
23600
23601 if test "x$path" != "x$new_path"; then
23602 BOOT_JDK="$new_path"
23603 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23604 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23605 fi
23606
23607 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23608
23609 path="$BOOT_JDK"
23610 has_colon=`$ECHO $path | $GREP ^.:`
23611 new_path="$path"
23612 if test "x$has_colon" = x; then
23613 # Not in mixed or Windows style, start by that.
23614 new_path=`cmd //c echo $path`
23615 fi
23616
23617
23618 input_path="$new_path"
23619 # Check if we need to convert this using DOS-style short mode. If the path
23620 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23621 # take no chances and rewrite it.
23622 # Note: m4 eats our [], so we need to use [ and ] instead.
23623 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23624 if test "x$has_forbidden_chars" != x; then
23625 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23626 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23627 fi
23628
23629
23630 windows_path="$new_path"
23631 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23632 unix_path=`$CYGPATH -u "$windows_path"`
23633 new_path="$unix_path"
23634 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23635 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23636 new_path="$unix_path"
23637 fi
23638
23639 if test "x$path" != "x$new_path"; then
23640 BOOT_JDK="$new_path"
23641 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23642 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23643 fi
23644
23645 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23646 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23647
23648 else
23649 # We're on a unix platform. Hooray! :)
23650 path="$BOOT_JDK"
23651 has_space=`$ECHO "$path" | $GREP " "`
23652 if test "x$has_space" != x; then
23653 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23654 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23655 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23656 fi
23657
23658 # Use eval to expand a potential ~
23659 eval path="$path"
23660 if test ! -f "$path" && test ! -d "$path"; then
23661 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23662 fi
23663
23664 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23665 fi
23666 fi
23667
23668 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23669 $as_echo_n "checking for Boot JDK... " >&6; }
23670 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23671 $as_echo "$BOOT_JDK" >&6; }
23672 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23673 $as_echo_n "checking Boot JDK version... " >&6; }
23674 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23676 $as_echo "$BOOT_JDK_VERSION" >&6; }
23677 fi # end check jdk version
23678 fi # end check javac
23679 fi # end check java
23680 fi # end check boot jdk found
23681 fi
23682
23683 done
23684 fi
23685
23686 fi
23687
23688
23689 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23690 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23691 # Do we have a bin/java?
23692 if test ! -x "$BOOT_JDK/bin/java"; then
23693 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23694 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23695 BOOT_JDK_FOUND=no
23696 else
23697 # Do we have a bin/javac?
23698 if test ! -x "$BOOT_JDK/bin/javac"; then
23699 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23700 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23701 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23702 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23703 BOOT_JDK_FOUND=no
23704 else
23705 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23706 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23707
23708 # Extra M4 quote needed to protect [] in grep expression.
23709 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23710 if test "x$FOUND_CORRECT_VERSION" = x; then
23711 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23712 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23713 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23714 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23715 BOOT_JDK_FOUND=no
23716 else
23717 # We're done! :-)
23718 BOOT_JDK_FOUND=yes
23719
23720 # Only process if variable expands to non-empty
23721
23722 if test "x$BOOT_JDK" != x; then
23723 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23724
23725 # Input might be given as Windows format, start by converting to
23726 # unix format.
23727 path="$BOOT_JDK"
23728 new_path=`$CYGPATH -u "$path"`
23729
23730 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23731 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23732 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23733 # "foo.exe" is OK but "foo" is an error.
23734 #
23735 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23736 # It is also a way to make sure we got the proper file name for the real test later on.
23737 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23738 if test "x$test_shortpath" = x; then
23739 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23740 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23741 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23742 fi
23743
23744 # Call helper function which possibly converts this using DOS-style short mode.
23745 # If so, the updated path is stored in $new_path.
23746
23747 input_path="$new_path"
23748 # Check if we need to convert this using DOS-style short mode. If the path
23749 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23750 # take no chances and rewrite it.
23751 # Note: m4 eats our [], so we need to use [ and ] instead.
23752 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23753 if test "x$has_forbidden_chars" != x; then
23754 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23755 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23756 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23757 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23758 # Going to short mode and back again did indeed matter. Since short mode is
23759 # case insensitive, let's make it lowercase to improve readability.
23760 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23761 # Now convert it back to Unix-style (cygpath)
23762 input_path=`$CYGPATH -u "$shortmode_path"`
23763 new_path="$input_path"
23764 fi
23765 fi
23766
23767 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23768 if test "x$test_cygdrive_prefix" = x; then
23769 # As a simple fix, exclude /usr/bin since it's not a real path.
23770 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23771 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23772 # a path prefixed by /cygdrive for fixpath to work.
23773 new_path="$CYGWIN_ROOT_PATH$input_path"
23774 fi
23775 fi
23776
23777
23778 if test "x$path" != "x$new_path"; then
23779 BOOT_JDK="$new_path"
23780 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23781 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23782 fi
23783
23784 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23785
23786 path="$BOOT_JDK"
23787 has_colon=`$ECHO $path | $GREP ^.:`
23788 new_path="$path"
23789 if test "x$has_colon" = x; then
23790 # Not in mixed or Windows style, start by that.
23791 new_path=`cmd //c echo $path`
23792 fi
23793
23794
23795 input_path="$new_path"
23796 # Check if we need to convert this using DOS-style short mode. If the path
23797 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23798 # take no chances and rewrite it.
23799 # Note: m4 eats our [], so we need to use [ and ] instead.
23800 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23801 if test "x$has_forbidden_chars" != x; then
23802 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23803 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23804 fi
23805
23806
23807 windows_path="$new_path"
23808 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23809 unix_path=`$CYGPATH -u "$windows_path"`
23810 new_path="$unix_path"
23811 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23812 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23813 new_path="$unix_path"
23814 fi
23815
23816 if test "x$path" != "x$new_path"; then
23817 BOOT_JDK="$new_path"
23818 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23819 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23820 fi
23821
23822 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23823 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23824
23825 else
23826 # We're on a unix platform. Hooray! :)
23827 path="$BOOT_JDK"
23828 has_space=`$ECHO "$path" | $GREP " "`
23829 if test "x$has_space" != x; then
23830 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23831 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23832 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23833 fi
23834
23835 # Use eval to expand a potential ~
23836 eval path="$path"
23837 if test ! -f "$path" && test ! -d "$path"; then
23838 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23839 fi
23840
23841 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23842 fi
23843 fi
23844
23845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23846 $as_echo_n "checking for Boot JDK... " >&6; }
23847 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23848 $as_echo "$BOOT_JDK" >&6; }
23849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23850 $as_echo_n "checking Boot JDK version... " >&6; }
23851 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23853 $as_echo "$BOOT_JDK_VERSION" >&6; }
23854 fi # end check jdk version
23855 fi # end check javac
23856 fi # end check java
23857 fi # end check boot jdk found
23858 fi
23859
23860
23861 if test "x$BOOT_JDK_FOUND" = xno; then
23862 # Now execute the test
23863
23864 BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23865 BOOT_JDK_SUFFIX=""
23866 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23867 if test "x$ALL_JDKS_FOUND" != x; then
23868 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23869
23870 if test "x$BOOT_JDK_FOUND" = xno; then
23871 # Now execute the test
23872
23873 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23874 if test -d "$BOOT_JDK"; then
23875 BOOT_JDK_FOUND=maybe
23876 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23877 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23878 fi
23879
23880
23881 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23882 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23883 # Do we have a bin/java?
23884 if test ! -x "$BOOT_JDK/bin/java"; then
23885 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23886 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23887 BOOT_JDK_FOUND=no
23888 else
23889 # Do we have a bin/javac?
23890 if test ! -x "$BOOT_JDK/bin/javac"; then
23891 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23892 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23893 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23894 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23895 BOOT_JDK_FOUND=no
23896 else
23897 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23898 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23899
23900 # Extra M4 quote needed to protect [] in grep expression.
23901 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23902 if test "x$FOUND_CORRECT_VERSION" = x; then
23903 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23904 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23905 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23906 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23907 BOOT_JDK_FOUND=no
23908 else
23909 # We're done! :-)
23910 BOOT_JDK_FOUND=yes
23911
23912 # Only process if variable expands to non-empty
23913
23914 if test "x$BOOT_JDK" != x; then
23915 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23916
23917 # Input might be given as Windows format, start by converting to
23918 # unix format.
23919 path="$BOOT_JDK"
23920 new_path=`$CYGPATH -u "$path"`
23921
23922 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23923 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23924 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23925 # "foo.exe" is OK but "foo" is an error.
23926 #
23927 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23928 # It is also a way to make sure we got the proper file name for the real test later on.
23929 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23930 if test "x$test_shortpath" = x; then
23931 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23932 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23933 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23934 fi
23935
23936 # Call helper function which possibly converts this using DOS-style short mode.
23937 # If so, the updated path is stored in $new_path.
23938
23939 input_path="$new_path"
23940 # Check if we need to convert this using DOS-style short mode. If the path
23941 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23942 # take no chances and rewrite it.
23943 # Note: m4 eats our [], so we need to use [ and ] instead.
23944 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23945 if test "x$has_forbidden_chars" != x; then
23946 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23947 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23948 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23949 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23950 # Going to short mode and back again did indeed matter. Since short mode is
23951 # case insensitive, let's make it lowercase to improve readability.
23952 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23953 # Now convert it back to Unix-style (cygpath)
23954 input_path=`$CYGPATH -u "$shortmode_path"`
23955 new_path="$input_path"
23956 fi
23957 fi
23958
23959 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23960 if test "x$test_cygdrive_prefix" = x; then
23961 # As a simple fix, exclude /usr/bin since it's not a real path.
23962 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23963 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23964 # a path prefixed by /cygdrive for fixpath to work.
23965 new_path="$CYGWIN_ROOT_PATH$input_path"
23966 fi
23967 fi
23968
23969
23970 if test "x$path" != "x$new_path"; then
23971 BOOT_JDK="$new_path"
23972 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23973 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23974 fi
23975
23976 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23977
23978 path="$BOOT_JDK"
23979 has_colon=`$ECHO $path | $GREP ^.:`
23980 new_path="$path"
23981 if test "x$has_colon" = x; then
23982 # Not in mixed or Windows style, start by that.
23983 new_path=`cmd //c echo $path`
23984 fi
23985
23986
23987 input_path="$new_path"
23988 # Check if we need to convert this using DOS-style short mode. If the path
23989 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23990 # take no chances and rewrite it.
23991 # Note: m4 eats our [], so we need to use [ and ] instead.
23992 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23993 if test "x$has_forbidden_chars" != x; then
23994 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23995 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23996 fi
23997
23998
23999 windows_path="$new_path"
24000 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24001 unix_path=`$CYGPATH -u "$windows_path"`
24002 new_path="$unix_path"
24003 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24004 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24005 new_path="$unix_path"
24006 fi
24007
24008 if test "x$path" != "x$new_path"; then
24009 BOOT_JDK="$new_path"
24010 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24011 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24012 fi
24013
24014 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24015 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24016
24017 else
24018 # We're on a unix platform. Hooray! :)
24019 path="$BOOT_JDK"
24020 has_space=`$ECHO "$path" | $GREP " "`
24021 if test "x$has_space" != x; then
24022 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24023 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24024 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24025 fi
24026
24027 # Use eval to expand a potential ~
24028 eval path="$path"
24029 if test ! -f "$path" && test ! -d "$path"; then
24030 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24031 fi
24032
24033 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24034 fi
24035 fi
24036
24037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24038 $as_echo_n "checking for Boot JDK... " >&6; }
24039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24040 $as_echo "$BOOT_JDK" >&6; }
24041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24042 $as_echo_n "checking Boot JDK version... " >&6; }
24043 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24044 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24045 $as_echo "$BOOT_JDK_VERSION" >&6; }
24046 fi # end check jdk version
24047 fi # end check javac
24048 fi # end check java
24049 fi # end check boot jdk found
24050 fi
24051
24052 done
24053 fi
24054
24055
24056 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24057 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24058 # Do we have a bin/java?
24059 if test ! -x "$BOOT_JDK/bin/java"; then
24060 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24061 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24062 BOOT_JDK_FOUND=no
24063 else
24064 # Do we have a bin/javac?
24065 if test ! -x "$BOOT_JDK/bin/javac"; then
24066 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24067 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24068 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24069 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24070 BOOT_JDK_FOUND=no
24071 else
24072 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24073 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24074
24075 # Extra M4 quote needed to protect [] in grep expression.
24076 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24077 if test "x$FOUND_CORRECT_VERSION" = x; then
24078 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24079 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24080 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24081 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24082 BOOT_JDK_FOUND=no
24083 else
24084 # We're done! :-)
24085 BOOT_JDK_FOUND=yes
24086
24087 # Only process if variable expands to non-empty
24088
24089 if test "x$BOOT_JDK" != x; then
24090 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24091
24092 # Input might be given as Windows format, start by converting to
24093 # unix format.
24094 path="$BOOT_JDK"
24095 new_path=`$CYGPATH -u "$path"`
24096
24097 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24098 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24099 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24100 # "foo.exe" is OK but "foo" is an error.
24101 #
24102 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24103 # It is also a way to make sure we got the proper file name for the real test later on.
24104 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24105 if test "x$test_shortpath" = x; then
24106 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24107 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24108 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24109 fi
24110
24111 # Call helper function which possibly converts this using DOS-style short mode.
24112 # If so, the updated path is stored in $new_path.
24113
24114 input_path="$new_path"
24115 # Check if we need to convert this using DOS-style short mode. If the path
24116 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24117 # take no chances and rewrite it.
24118 # Note: m4 eats our [], so we need to use [ and ] instead.
24119 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24120 if test "x$has_forbidden_chars" != x; then
24121 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24122 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24123 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24124 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24125 # Going to short mode and back again did indeed matter. Since short mode is
24126 # case insensitive, let's make it lowercase to improve readability.
24127 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24128 # Now convert it back to Unix-style (cygpath)
24129 input_path=`$CYGPATH -u "$shortmode_path"`
24130 new_path="$input_path"
24131 fi
24132 fi
24133
24134 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24135 if test "x$test_cygdrive_prefix" = x; then
24136 # As a simple fix, exclude /usr/bin since it's not a real path.
24137 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24138 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24139 # a path prefixed by /cygdrive for fixpath to work.
24140 new_path="$CYGWIN_ROOT_PATH$input_path"
24141 fi
24142 fi
24143
24144
24145 if test "x$path" != "x$new_path"; then
24146 BOOT_JDK="$new_path"
24147 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24148 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24149 fi
24150
24151 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24152
24153 path="$BOOT_JDK"
24154 has_colon=`$ECHO $path | $GREP ^.:`
24155 new_path="$path"
24156 if test "x$has_colon" = x; then
24157 # Not in mixed or Windows style, start by that.
24158 new_path=`cmd //c echo $path`
24159 fi
24160
24161
24162 input_path="$new_path"
24163 # Check if we need to convert this using DOS-style short mode. If the path
24164 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24165 # take no chances and rewrite it.
24166 # Note: m4 eats our [], so we need to use [ and ] instead.
24167 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24168 if test "x$has_forbidden_chars" != x; then
24169 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24170 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24171 fi
24172
24173
24174 windows_path="$new_path"
24175 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24176 unix_path=`$CYGPATH -u "$windows_path"`
24177 new_path="$unix_path"
24178 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24179 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24180 new_path="$unix_path"
24181 fi
24182
24183 if test "x$path" != "x$new_path"; then
24184 BOOT_JDK="$new_path"
24185 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24186 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24187 fi
24188
24189 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24190 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24191
24192 else
24193 # We're on a unix platform. Hooray! :)
24194 path="$BOOT_JDK"
24195 has_space=`$ECHO "$path" | $GREP " "`
24196 if test "x$has_space" != x; then
24197 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24198 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24199 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24200 fi
24201
24202 # Use eval to expand a potential ~
24203 eval path="$path"
24204 if test ! -f "$path" && test ! -d "$path"; then
24205 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24206 fi
24207
24208 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24209 fi
24210 fi
24211
24212 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24213 $as_echo_n "checking for Boot JDK... " >&6; }
24214 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24215 $as_echo "$BOOT_JDK" >&6; }
24216 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24217 $as_echo_n "checking Boot JDK version... " >&6; }
24218 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24219 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24220 $as_echo "$BOOT_JDK_VERSION" >&6; }
24221 fi # end check jdk version
24222 fi # end check javac
24223 fi # end check java
24224 fi # end check boot jdk found
24225 fi
24226
24227 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
24228
24229 if test "x$BOOT_JDK_FOUND" = xno; then
24230 # Now execute the test
24231
24232 BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
24233 BOOT_JDK_SUFFIX="/Contents/Home"
24234 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24235 if test "x$ALL_JDKS_FOUND" != x; then
24236 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24237
24238 if test "x$BOOT_JDK_FOUND" = xno; then
24239 # Now execute the test
24240
24241 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24242 if test -d "$BOOT_JDK"; then
24243 BOOT_JDK_FOUND=maybe
24244 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24245 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24246 fi
24247
24248
24249 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24250 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24251 # Do we have a bin/java?
24252 if test ! -x "$BOOT_JDK/bin/java"; then
24253 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24254 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24255 BOOT_JDK_FOUND=no
24256 else
24257 # Do we have a bin/javac?
24258 if test ! -x "$BOOT_JDK/bin/javac"; then
24259 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24260 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24261 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24262 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24263 BOOT_JDK_FOUND=no
24264 else
24265 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24266 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24267
24268 # Extra M4 quote needed to protect [] in grep expression.
24269 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24270 if test "x$FOUND_CORRECT_VERSION" = x; then
24271 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24272 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24273 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24274 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24275 BOOT_JDK_FOUND=no
24276 else
24277 # We're done! :-)
24278 BOOT_JDK_FOUND=yes
24279
24280 # Only process if variable expands to non-empty
24281
24282 if test "x$BOOT_JDK" != x; then
24283 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24284
24285 # Input might be given as Windows format, start by converting to
24286 # unix format.
24287 path="$BOOT_JDK"
24288 new_path=`$CYGPATH -u "$path"`
24289
24290 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24291 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24292 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24293 # "foo.exe" is OK but "foo" is an error.
24294 #
24295 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24296 # It is also a way to make sure we got the proper file name for the real test later on.
24297 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24298 if test "x$test_shortpath" = x; then
24299 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24300 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24301 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24302 fi
24303
24304 # Call helper function which possibly converts this using DOS-style short mode.
24305 # If so, the updated path is stored in $new_path.
24306
24307 input_path="$new_path"
24308 # Check if we need to convert this using DOS-style short mode. If the path
24309 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24310 # take no chances and rewrite it.
24311 # Note: m4 eats our [], so we need to use [ and ] instead.
24312 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24313 if test "x$has_forbidden_chars" != x; then
24314 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24315 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24316 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24317 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24318 # Going to short mode and back again did indeed matter. Since short mode is
24319 # case insensitive, let's make it lowercase to improve readability.
24320 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24321 # Now convert it back to Unix-style (cygpath)
24322 input_path=`$CYGPATH -u "$shortmode_path"`
24323 new_path="$input_path"
24324 fi
24325 fi
24326
24327 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24328 if test "x$test_cygdrive_prefix" = x; then
24329 # As a simple fix, exclude /usr/bin since it's not a real path.
24330 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24331 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24332 # a path prefixed by /cygdrive for fixpath to work.
24333 new_path="$CYGWIN_ROOT_PATH$input_path"
24334 fi
24335 fi
24336
24337
24338 if test "x$path" != "x$new_path"; then
24339 BOOT_JDK="$new_path"
24340 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24341 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24342 fi
24343
24344 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24345
24346 path="$BOOT_JDK"
24347 has_colon=`$ECHO $path | $GREP ^.:`
24348 new_path="$path"
24349 if test "x$has_colon" = x; then
24350 # Not in mixed or Windows style, start by that.
24351 new_path=`cmd //c echo $path`
24352 fi
24353
24354
24355 input_path="$new_path"
24356 # Check if we need to convert this using DOS-style short mode. If the path
24357 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24358 # take no chances and rewrite it.
24359 # Note: m4 eats our [], so we need to use [ and ] instead.
24360 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24361 if test "x$has_forbidden_chars" != x; then
24362 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24363 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24364 fi
24365
24366
24367 windows_path="$new_path"
24368 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24369 unix_path=`$CYGPATH -u "$windows_path"`
24370 new_path="$unix_path"
24371 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24372 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24373 new_path="$unix_path"
24374 fi
24375
24376 if test "x$path" != "x$new_path"; then
24377 BOOT_JDK="$new_path"
24378 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24379 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24380 fi
24381
24382 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24383 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24384
24385 else
24386 # We're on a unix platform. Hooray! :)
24387 path="$BOOT_JDK"
24388 has_space=`$ECHO "$path" | $GREP " "`
24389 if test "x$has_space" != x; then
24390 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24391 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24392 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24393 fi
24394
24395 # Use eval to expand a potential ~
24396 eval path="$path"
24397 if test ! -f "$path" && test ! -d "$path"; then
24398 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24399 fi
24400
24401 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24402 fi
24403 fi
24404
24405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24406 $as_echo_n "checking for Boot JDK... " >&6; }
24407 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24408 $as_echo "$BOOT_JDK" >&6; }
24409 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24410 $as_echo_n "checking Boot JDK version... " >&6; }
24411 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24412 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24413 $as_echo "$BOOT_JDK_VERSION" >&6; }
24414 fi # end check jdk version
24415 fi # end check javac
24416 fi # end check java
24417 fi # end check boot jdk found
24418 fi
24419
24420 done
24421 fi
24422
24423
24424 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24425 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24426 # Do we have a bin/java?
24427 if test ! -x "$BOOT_JDK/bin/java"; then
24428 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24430 BOOT_JDK_FOUND=no
24431 else
24432 # Do we have a bin/javac?
24433 if test ! -x "$BOOT_JDK/bin/javac"; then
24434 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24435 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24436 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24437 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24438 BOOT_JDK_FOUND=no
24439 else
24440 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24441 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24442
24443 # Extra M4 quote needed to protect [] in grep expression.
24444 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24445 if test "x$FOUND_CORRECT_VERSION" = x; then
24446 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24447 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24448 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24449 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24450 BOOT_JDK_FOUND=no
24451 else
24452 # We're done! :-)
24453 BOOT_JDK_FOUND=yes
24454
24455 # Only process if variable expands to non-empty
24456
24457 if test "x$BOOT_JDK" != x; then
24458 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24459
24460 # Input might be given as Windows format, start by converting to
24461 # unix format.
24462 path="$BOOT_JDK"
24463 new_path=`$CYGPATH -u "$path"`
24464
24465 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24466 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24467 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24468 # "foo.exe" is OK but "foo" is an error.
24469 #
24470 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24471 # It is also a way to make sure we got the proper file name for the real test later on.
24472 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24473 if test "x$test_shortpath" = x; then
24474 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24475 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24476 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24477 fi
24478
24479 # Call helper function which possibly converts this using DOS-style short mode.
24480 # If so, the updated path is stored in $new_path.
24481
24482 input_path="$new_path"
24483 # Check if we need to convert this using DOS-style short mode. If the path
24484 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24485 # take no chances and rewrite it.
24486 # Note: m4 eats our [], so we need to use [ and ] instead.
24487 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24488 if test "x$has_forbidden_chars" != x; then
24489 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24490 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24491 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24492 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24493 # Going to short mode and back again did indeed matter. Since short mode is
24494 # case insensitive, let's make it lowercase to improve readability.
24495 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24496 # Now convert it back to Unix-style (cygpath)
24497 input_path=`$CYGPATH -u "$shortmode_path"`
24498 new_path="$input_path"
24499 fi
24500 fi
24501
24502 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24503 if test "x$test_cygdrive_prefix" = x; then
24504 # As a simple fix, exclude /usr/bin since it's not a real path.
24505 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24506 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24507 # a path prefixed by /cygdrive for fixpath to work.
24508 new_path="$CYGWIN_ROOT_PATH$input_path"
24509 fi
24510 fi
24511
24512
24513 if test "x$path" != "x$new_path"; then
24514 BOOT_JDK="$new_path"
24515 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24516 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24517 fi
24518
24519 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24520
24521 path="$BOOT_JDK"
24522 has_colon=`$ECHO $path | $GREP ^.:`
24523 new_path="$path"
24524 if test "x$has_colon" = x; then
24525 # Not in mixed or Windows style, start by that.
24526 new_path=`cmd //c echo $path`
24527 fi
24528
24529
24530 input_path="$new_path"
24531 # Check if we need to convert this using DOS-style short mode. If the path
24532 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24533 # take no chances and rewrite it.
24534 # Note: m4 eats our [], so we need to use [ and ] instead.
24535 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24536 if test "x$has_forbidden_chars" != x; then
24537 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24538 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24539 fi
24540
24541
24542 windows_path="$new_path"
24543 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24544 unix_path=`$CYGPATH -u "$windows_path"`
24545 new_path="$unix_path"
24546 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24547 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24548 new_path="$unix_path"
24549 fi
24550
24551 if test "x$path" != "x$new_path"; then
24552 BOOT_JDK="$new_path"
24553 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24554 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24555 fi
24556
24557 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24558 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24559
24560 else
24561 # We're on a unix platform. Hooray! :)
24562 path="$BOOT_JDK"
24563 has_space=`$ECHO "$path" | $GREP " "`
24564 if test "x$has_space" != x; then
24565 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24566 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24567 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24568 fi
24569
24570 # Use eval to expand a potential ~
24571 eval path="$path"
24572 if test ! -f "$path" && test ! -d "$path"; then
24573 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24574 fi
24575
24576 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24577 fi
24578 fi
24579
24580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24581 $as_echo_n "checking for Boot JDK... " >&6; }
24582 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24583 $as_echo "$BOOT_JDK" >&6; }
24584 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24585 $as_echo_n "checking Boot JDK version... " >&6; }
24586 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24587 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24588 $as_echo "$BOOT_JDK_VERSION" >&6; }
24589 fi # end check jdk version
24590 fi # end check javac
24591 fi # end check java
24592 fi # end check boot jdk found
24593 fi
24594
24595
24596 if test "x$BOOT_JDK_FOUND" = xno; then
24597 # Now execute the test
24598
24599 BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24600 BOOT_JDK_SUFFIX="/Contents/Home"
24601 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24602 if test "x$ALL_JDKS_FOUND" != x; then
24603 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24604
24605 if test "x$BOOT_JDK_FOUND" = xno; then
24606 # Now execute the test
24607
24608 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24609 if test -d "$BOOT_JDK"; then
24610 BOOT_JDK_FOUND=maybe
24611 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24612 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24613 fi
24614
24615
24616 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24617 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24618 # Do we have a bin/java?
24619 if test ! -x "$BOOT_JDK/bin/java"; then
24620 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24621 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24622 BOOT_JDK_FOUND=no
24623 else
24624 # Do we have a bin/javac?
24625 if test ! -x "$BOOT_JDK/bin/javac"; then
24626 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24627 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24628 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24629 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24630 BOOT_JDK_FOUND=no
24631 else
24632 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24633 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24634
24635 # Extra M4 quote needed to protect [] in grep expression.
24636 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24637 if test "x$FOUND_CORRECT_VERSION" = x; then
24638 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24639 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24640 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24641 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24642 BOOT_JDK_FOUND=no
24643 else
24644 # We're done! :-)
24645 BOOT_JDK_FOUND=yes
24646
24647 # Only process if variable expands to non-empty
24648
24649 if test "x$BOOT_JDK" != x; then
24650 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24651
24652 # Input might be given as Windows format, start by converting to
24653 # unix format.
24654 path="$BOOT_JDK"
24655 new_path=`$CYGPATH -u "$path"`
24656
24657 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24658 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24659 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24660 # "foo.exe" is OK but "foo" is an error.
24661 #
24662 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24663 # It is also a way to make sure we got the proper file name for the real test later on.
24664 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24665 if test "x$test_shortpath" = x; then
24666 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24667 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24668 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24669 fi
24670
24671 # Call helper function which possibly converts this using DOS-style short mode.
24672 # If so, the updated path is stored in $new_path.
24673
24674 input_path="$new_path"
24675 # Check if we need to convert this using DOS-style short mode. If the path
24676 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24677 # take no chances and rewrite it.
24678 # Note: m4 eats our [], so we need to use [ and ] instead.
24679 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24680 if test "x$has_forbidden_chars" != x; then
24681 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24682 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24683 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24684 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24685 # Going to short mode and back again did indeed matter. Since short mode is
24686 # case insensitive, let's make it lowercase to improve readability.
24687 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24688 # Now convert it back to Unix-style (cygpath)
24689 input_path=`$CYGPATH -u "$shortmode_path"`
24690 new_path="$input_path"
24691 fi
24692 fi
24693
24694 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24695 if test "x$test_cygdrive_prefix" = x; then
24696 # As a simple fix, exclude /usr/bin since it's not a real path.
24697 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24698 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24699 # a path prefixed by /cygdrive for fixpath to work.
24700 new_path="$CYGWIN_ROOT_PATH$input_path"
24701 fi
24702 fi
24703
24704
24705 if test "x$path" != "x$new_path"; then
24706 BOOT_JDK="$new_path"
24707 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24708 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24709 fi
24710
24711 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24712
24713 path="$BOOT_JDK"
24714 has_colon=`$ECHO $path | $GREP ^.:`
24715 new_path="$path"
24716 if test "x$has_colon" = x; then
24717 # Not in mixed or Windows style, start by that.
24718 new_path=`cmd //c echo $path`
24719 fi
24720
24721
24722 input_path="$new_path"
24723 # Check if we need to convert this using DOS-style short mode. If the path
24724 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24725 # take no chances and rewrite it.
24726 # Note: m4 eats our [], so we need to use [ and ] instead.
24727 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24728 if test "x$has_forbidden_chars" != x; then
24729 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24730 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24731 fi
24732
24733
24734 windows_path="$new_path"
24735 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24736 unix_path=`$CYGPATH -u "$windows_path"`
24737 new_path="$unix_path"
24738 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24739 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24740 new_path="$unix_path"
24741 fi
24742
24743 if test "x$path" != "x$new_path"; then
24744 BOOT_JDK="$new_path"
24745 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24746 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24747 fi
24748
24749 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24750 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24751
24752 else
24753 # We're on a unix platform. Hooray! :)
24754 path="$BOOT_JDK"
24755 has_space=`$ECHO "$path" | $GREP " "`
24756 if test "x$has_space" != x; then
24757 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24758 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24759 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24760 fi
24761
24762 # Use eval to expand a potential ~
24763 eval path="$path"
24764 if test ! -f "$path" && test ! -d "$path"; then
24765 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24766 fi
24767
24768 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24769 fi
24770 fi
24771
24772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24773 $as_echo_n "checking for Boot JDK... " >&6; }
24774 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24775 $as_echo "$BOOT_JDK" >&6; }
24776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24777 $as_echo_n "checking Boot JDK version... " >&6; }
24778 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24779 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24780 $as_echo "$BOOT_JDK_VERSION" >&6; }
24781 fi # end check jdk version
24782 fi # end check javac
24783 fi # end check java
24784 fi # end check boot jdk found
24785 fi
24786
24787 done
24788 fi
24789
24790
24791 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24792 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24793 # Do we have a bin/java?
24794 if test ! -x "$BOOT_JDK/bin/java"; then
24795 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24796 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24797 BOOT_JDK_FOUND=no
24798 else
24799 # Do we have a bin/javac?
24800 if test ! -x "$BOOT_JDK/bin/javac"; then
24801 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24802 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24803 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24804 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24805 BOOT_JDK_FOUND=no
24806 else
24807 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24808 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24809
24810 # Extra M4 quote needed to protect [] in grep expression.
24811 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24812 if test "x$FOUND_CORRECT_VERSION" = x; then
24813 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24815 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24816 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24817 BOOT_JDK_FOUND=no
24818 else
24819 # We're done! :-)
24820 BOOT_JDK_FOUND=yes
24821
24822 # Only process if variable expands to non-empty
24823
24824 if test "x$BOOT_JDK" != x; then
24825 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24826
24827 # Input might be given as Windows format, start by converting to
24828 # unix format.
24829 path="$BOOT_JDK"
24830 new_path=`$CYGPATH -u "$path"`
24831
24832 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24833 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24834 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24835 # "foo.exe" is OK but "foo" is an error.
24836 #
24837 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24838 # It is also a way to make sure we got the proper file name for the real test later on.
24839 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24840 if test "x$test_shortpath" = x; then
24841 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24842 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24843 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24844 fi
24845
24846 # Call helper function which possibly converts this using DOS-style short mode.
24847 # If so, the updated path is stored in $new_path.
24848
24849 input_path="$new_path"
24850 # Check if we need to convert this using DOS-style short mode. If the path
24851 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24852 # take no chances and rewrite it.
24853 # Note: m4 eats our [], so we need to use [ and ] instead.
24854 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24855 if test "x$has_forbidden_chars" != x; then
24856 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24857 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24858 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24859 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24860 # Going to short mode and back again did indeed matter. Since short mode is
24861 # case insensitive, let's make it lowercase to improve readability.
24862 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24863 # Now convert it back to Unix-style (cygpath)
24864 input_path=`$CYGPATH -u "$shortmode_path"`
24865 new_path="$input_path"
24866 fi
24867 fi
24868
24869 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24870 if test "x$test_cygdrive_prefix" = x; then
24871 # As a simple fix, exclude /usr/bin since it's not a real path.
24872 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24873 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24874 # a path prefixed by /cygdrive for fixpath to work.
24875 new_path="$CYGWIN_ROOT_PATH$input_path"
24876 fi
24877 fi
24878
24879
24880 if test "x$path" != "x$new_path"; then
24881 BOOT_JDK="$new_path"
24882 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24883 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24884 fi
24885
24886 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24887
24888 path="$BOOT_JDK"
24889 has_colon=`$ECHO $path | $GREP ^.:`
24890 new_path="$path"
24891 if test "x$has_colon" = x; then
24892 # Not in mixed or Windows style, start by that.
24893 new_path=`cmd //c echo $path`
24894 fi
24895
24896
24897 input_path="$new_path"
24898 # Check if we need to convert this using DOS-style short mode. If the path
24899 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24900 # take no chances and rewrite it.
24901 # Note: m4 eats our [], so we need to use [ and ] instead.
24902 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24903 if test "x$has_forbidden_chars" != x; then
24904 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24905 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24906 fi
24907
24908
24909 windows_path="$new_path"
24910 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24911 unix_path=`$CYGPATH -u "$windows_path"`
24912 new_path="$unix_path"
24913 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24914 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24915 new_path="$unix_path"
24916 fi
24917
24918 if test "x$path" != "x$new_path"; then
24919 BOOT_JDK="$new_path"
24920 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24921 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24922 fi
24923
24924 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24925 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24926
24927 else
24928 # We're on a unix platform. Hooray! :)
24929 path="$BOOT_JDK"
24930 has_space=`$ECHO "$path" | $GREP " "`
24931 if test "x$has_space" != x; then
24932 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24933 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24934 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24935 fi
24936
24937 # Use eval to expand a potential ~
24938 eval path="$path"
24939 if test ! -f "$path" && test ! -d "$path"; then
24940 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24941 fi
24942
24943 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24944 fi
24945 fi
24946
24947 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24948 $as_echo_n "checking for Boot JDK... " >&6; }
24949 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24950 $as_echo "$BOOT_JDK" >&6; }
24951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24952 $as_echo_n "checking Boot JDK version... " >&6; }
24953 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24954 { $as_echo "$as_me:${as_line