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 VERSION_SHORT
829 VERSION_STRING
830 VERSION_NUMBER_FOUR_POSITIONS
831 VERSION_NUMBER
832 VERSION_OPT
833 VERSION_BUILD
834 VERSION_PRE
835 VERSION_PATCH
836 VERSION_SECURITY
837 VERSION_MINOR
838 VERSION_MAJOR
839 MACOSX_BUNDLE_ID_BASE
840 MACOSX_BUNDLE_NAME_BASE
841 COMPANY_NAME
842 JDK_RC_PLATFORM_NAME
843 PRODUCT_SUFFIX
844 PRODUCT_NAME
845 LAUNCHER_NAME
846 COPYRIGHT_YEAR
847 COMPRESS_JARS
848 RMICONNECTOR_IIOP
849 UNLIMITED_CRYPTO
850 CACERTS_FILE
851 TEST_IN_BUILD
852 BUILD_HEADLESS
853 SUPPORT_HEADFUL
854 SUPPORT_HEADLESS
855 BDEPS_FTP
856 BDEPS_UNZIP
857 OS_VERSION_MICRO
858 OS_VERSION_MINOR
859 OS_VERSION_MAJOR
860 PKG_CONFIG
861 BASH_ARGS
862 CODESIGN
863 XATTR
864 DSYMUTIL
865 IS_GNU_TIME
866 TIME
867 STAT
868 HG
869 READELF
870 OTOOL
871 LDD
872 ZIP
873 UNZIP
874 FIND_DELETE
875 OUTPUT_SYNC
876 OUTPUT_SYNC_SUPPORTED
877 MAKE
878 CHECK_TOOLSDIR_MAKE
879 CHECK_TOOLSDIR_GMAKE
880 CHECK_MAKE
881 CHECK_GMAKE
882 PKGHANDLER
883 CONFIGURESUPPORT_OUTPUTDIR
884 OUTPUT_ROOT
885 CONF_NAME
886 SPEC
887 SDKROOT
888 XCODEBUILD
889 BUILD_VARIANT_RELEASE
890 DEBUG_CLASSFILES
891 FASTDEBUG
892 VARIANT
893 DEBUG_LEVEL
894 MACOSX_UNIVERSAL
895 INCLUDE_SA
896 JVM_VARIANT_CORE
897 JVM_VARIANT_ZEROSHARK
898 JVM_VARIANT_ZERO
899 JVM_VARIANT_KERNEL
900 JVM_VARIANT_MINIMAL1
901 JVM_VARIANT_CLIENT
902 JVM_VARIANT_SERVER
903 JVM_VARIANTS
904 JVM_INTERPRETER
905 JDK_VARIANT
906 SET_OPENJDK
907 CANONICAL_TOPDIR
908 ORIGINAL_TOPDIR
909 TOPDIR
910 PATH_SEP
911 ZERO_ARCHDEF
912 DEFINE_CROSS_COMPILE_ARCH
913 LP64
914 OPENJDK_TARGET_OS_EXPORT_DIR
915 OPENJDK_TARGET_CPU_JLI_CFLAGS
916 OPENJDK_TARGET_CPU_OSARCH
917 OPENJDK_TARGET_CPU_ISADIR
918 OPENJDK_TARGET_CPU_LIBDIR
919 OPENJDK_TARGET_CPU_LEGACY_LIB
920 OPENJDK_TARGET_CPU_LEGACY
921 REQUIRED_OS_VERSION
922 REQUIRED_OS_NAME
923 COMPILE_TYPE
924 OPENJDK_TARGET_CPU_ENDIAN
925 OPENJDK_TARGET_CPU_BITS
926 OPENJDK_TARGET_CPU_ARCH
927 OPENJDK_TARGET_CPU
928 OPENJDK_TARGET_OS_ENV
929 OPENJDK_TARGET_OS_TYPE
930 OPENJDK_TARGET_OS
931 OPENJDK_BUILD_CPU_ENDIAN
932 OPENJDK_BUILD_CPU_BITS
933 OPENJDK_BUILD_CPU_ARCH
934 OPENJDK_BUILD_CPU
935 OPENJDK_BUILD_OS_ENV
936 OPENJDK_BUILD_OS_TYPE
937 OPENJDK_BUILD_OS
938 OPENJDK_BUILD_AUTOCONF_NAME
939 OPENJDK_TARGET_AUTOCONF_NAME
940 target_os
941 target_vendor
942 target_cpu
943 target
944 host_os
945 host_vendor
946 host_cpu
947 host
948 build_os
949 build_vendor
950 build_cpu
951 build
952 CPIO
953 SETFILE
954 DF
955 READLINK
956 CYGPATH
957 SED
958 FGREP
959 EGREP
960 GREP
961 AWK
962 XARGS
963 WHICH
964 WC
965 UNIQ
966 UNAME
967 TR
968 TOUCH
969 TEE
970 TAR
971 TAIL
972 SORT
973 SH
974 RM
975 PRINTF
976 NAWK
977 MV
978 MKTEMP
979 MKDIR
980 LS
981 LN
982 HEAD
983 FIND
984 FILE
985 EXPR
986 ECHO
987 DIRNAME
988 DIFF
989 DATE
990 CUT
991 CP
992 COMM
993 CMP
994 CHMOD
995 CAT
996 BASH
997 BASENAME
998 DATE_WHEN_CONFIGURED
999 ORIGINAL_PATH
1000 CONFIGURE_COMMAND_LINE
1001 target_alias
1002 host_alias
1003 build_alias
1004 LIBS
1005 ECHO_T
1006 ECHO_N
1007 ECHO_C
1008 DEFS
1009 mandir
1010 localedir
1011 libdir
1012 psdir
1013 pdfdir
1014 dvidir
1015 htmldir
1016 infodir
1017 docdir
1018 oldincludedir
1019 includedir
1020 localstatedir
1021 sharedstatedir
1022 sysconfdir
1023 datadir
1024 datarootdir
1025 libexecdir
1026 sbindir
1027 bindir
1028 program_transform_name
1029 prefix
1030 exec_prefix
1031 PACKAGE_URL
1032 PACKAGE_BUGREPORT
1033 PACKAGE_STRING
1034 PACKAGE_VERSION
1035 PACKAGE_TARNAME
1036 PACKAGE_NAME
1037 PATH_SEPARATOR
1038 SHELL'
1039 ac_subst_files=''
1040 ac_user_opts='
1041 enable_option_checking
1042 with_target_bits
1043 enable_openjdk_only
1044 with_custom_make_dir
1045 with_jdk_variant
1046 with_jvm_interpreter
1047 with_jvm_variants
1048 enable_debug
1049 with_debug_level
1050 with_devkit
1051 with_sys_root
1052 with_sysroot
1053 with_tools_dir
1054 with_toolchain_path
1055 with_extra_path
1056 with_sdk_name
1057 with_conf_name
1058 with_output_sync
1059 with_builddeps_conf
1060 with_builddeps_server
1061 with_builddeps_dir
1062 with_builddeps_group
1063 enable_headful
1064 enable_hotspot_test_in_build
1065 with_cacerts_file
1066 enable_unlimited_crypto
1067 enable_rmiconnector_iiop
1068 with_copyright_year
1069 with_milestone
1070 with_update_version
1071 with_user_release_suffix
1072 with_build_number
1073 with_version_string
1074 with_version_pre_base
1075 with_version_pre_debuglevel
1076 with_version_opt
1077 with_version_build
1078 with_version_major
1079 with_version_minor
1080 with_version_security
1081 with_version_patch
1082 with_boot_jdk
1083 with_add_source_root
1084 with_override_source_root
1085 with_adds_and_overrides
1086 with_override_langtools
1087 with_override_corba
1088 with_override_jaxp
1089 with_override_jaxws
1090 with_override_hotspot
1091 with_override_nashorn
1092 with_override_jdk
1093 with_import_hotspot
1094 with_toolchain_type
1095 with_toolchain_version
1096 with_jtreg
1097 with_extra_cflags
1098 with_extra_cxxflags
1099 with_extra_ldflags
1100 enable_warnings_as_errors
1101 enable_debug_symbols
1102 enable_zip_debug_info
1103 enable_native_coverage
1104 with_x
1105 with_cups
1106 with_cups_include
1107 with_freetype
1108 with_freetype_include
1109 with_freetype_lib
1110 with_freetype_src
1111 enable_freetype_bundling
1112 with_alsa
1113 with_alsa_include
1114 with_alsa_lib
1115 with_libjpeg
1116 with_giflib
1117 with_lcms
1118 with_libpng
1119 with_zlib
1120 with_stdc__lib
1121 with_msvcr_dll
1122 with_msvcp_dll
1123 with_dxsdk
1124 with_dxsdk_lib
1125 with_dxsdk_include
1126 with_num_cores
1127 with_memory_size
1128 with_jobs
1129 with_boot_jdk_jvmargs
1130 with_sjavac_server_java
1131 enable_sjavac
1132 enable_precompiled_headers
1133 enable_ccache
1134 with_ccache_dir
1135 '
1136 ac_precious_vars='build_alias
1137 host_alias
1138 target_alias
1139 BASENAME
1140 BASH
1141 CAT
1142 CHMOD
1143 CMP
1144 COMM
1145 CP
1146 CUT
1147 DATE
1148 DIFF
1149 DIRNAME
1150 ECHO
1151 EXPR
1152 FILE
1153 FIND
1154 HEAD
1155 LN
1156 LS
1157 MKDIR
1158 MKTEMP
1159 MV
1160 NAWK
1161 PRINTF
1162 RM
1163 SH
1164 SORT
1165 TAIL
1166 TAR
1167 TEE
1168 TOUCH
1169 TR
1170 UNAME
1171 UNIQ
1172 WC
1173 WHICH
1174 XARGS
1175 AWK
1176 GREP
1177 EGREP
1178 FGREP
1179 SED
1180 CYGPATH
1181 READLINK
1182 DF
1183 SETFILE
1184 CPIO
1185 UNZIP
1186 ZIP
1187 LDD
1188 OTOOL
1189 READELF
1190 HG
1191 STAT
1192 TIME
1193 DSYMUTIL
1194 XATTR
1195 CODESIGN
1196 PKG_CONFIG
1197 JAVA
1198 JAVAC
1199 JAVAH
1200 JAR
1201 JARSIGNER
1202 CC
1203 CFLAGS
1204 LDFLAGS
1205 LIBS
1206 CPPFLAGS
1207 CXX
1208 CXXFLAGS
1209 CCC
1210 CPP
1211 CXXCPP
1212 AS
1213 AR
1214 LIPO
1215 STRIP
1216 NM
1217 GNM
1218 OBJCOPY
1219 OBJDUMP
1220 BUILD_CC
1221 BUILD_CXX
1222 BUILD_LD
1223 JTREGEXE
1224 XMKMF
1225 FREETYPE_CFLAGS
1226 FREETYPE_LIBS
1227 ALSA_CFLAGS
1228 ALSA_LIBS
1229 LCMS_CFLAGS
1230 LCMS_LIBS
1231 PNG_CFLAGS
1232 PNG_LIBS
1233 LIBFFI_CFLAGS
1234 LIBFFI_LIBS
1235 CCACHE'
1236
1237
1238 # Initialize some variables set by options.
1239 ac_init_help=
1240 ac_init_version=false
1241 ac_unrecognized_opts=
1242 ac_unrecognized_sep=
1243 # The variables have the same names as the options, with
1244 # dashes changed to underlines.
1245 cache_file=/dev/null
1246 exec_prefix=NONE
1247 no_create=
1248 no_recursion=
1249 prefix=NONE
1250 program_prefix=NONE
1251 program_suffix=NONE
1252 program_transform_name=s,x,x,
1253 silent=
1254 site=
1255 srcdir=
1256 verbose=
1257 x_includes=NONE
1258 x_libraries=NONE
1259
1260 # Installation directory options.
1261 # These are left unexpanded so users can "make install exec_prefix=/foo"
1262 # and all the variables that are supposed to be based on exec_prefix
1263 # by default will actually change.
1264 # Use braces instead of parens because sh, perl, etc. also accept them.
1265 # (The list follows the same order as the GNU Coding Standards.)
1266 bindir='${exec_prefix}/bin'
1267 sbindir='${exec_prefix}/sbin'
1268 libexecdir='${exec_prefix}/libexec'
1269 datarootdir='${prefix}/share'
1270 datadir='${datarootdir}'
1271 sysconfdir='${prefix}/etc'
1272 sharedstatedir='${prefix}/com'
1273 localstatedir='${prefix}/var'
1274 includedir='${prefix}/include'
1275 oldincludedir='/usr/include'
1276 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1277 infodir='${datarootdir}/info'
1278 htmldir='${docdir}'
1279 dvidir='${docdir}'
1280 pdfdir='${docdir}'
1281 psdir='${docdir}'
1282 libdir='${exec_prefix}/lib'
1283 localedir='${datarootdir}/locale'
1284 mandir='${datarootdir}/man'
1285
1286 ac_prev=
1287 ac_dashdash=
1288 for ac_option
1289 do
1290 # If the previous option needs an argument, assign it.
1291 if test -n "$ac_prev"; then
1292 eval $ac_prev=\$ac_option
1293 ac_prev=
1294 continue
1295 fi
1296
1297 case $ac_option in
1298 *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1299 *=) ac_optarg= ;;
1300 *) ac_optarg=yes ;;
1301 esac
1302
1303 # Accept the important Cygnus configure options, so we can diagnose typos.
1304
1305 case $ac_dashdash$ac_option in
1306 --)
1307 ac_dashdash=yes ;;
1308
1309 -bindir | --bindir | --bindi | --bind | --bin | --bi)
1310 ac_prev=bindir ;;
1311 -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1312 bindir=$ac_optarg ;;
1313
1314 -build | --build | --buil | --bui | --bu)
1315 ac_prev=build_alias ;;
1316 -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1317 build_alias=$ac_optarg ;;
1318
1319 -cache-file | --cache-file | --cache-fil | --cache-fi \
1320 | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1321 ac_prev=cache_file ;;
1322 -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1323 | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1324 cache_file=$ac_optarg ;;
1325
1326 --config-cache | -C)
1327 cache_file=config.cache ;;
1328
1329 -datadir | --datadir | --datadi | --datad)
1330 ac_prev=datadir ;;
1331 -datadir=* | --datadir=* | --datadi=* | --datad=*)
1332 datadir=$ac_optarg ;;
1333
1334 -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1335 | --dataroo | --dataro | --datar)
1336 ac_prev=datarootdir ;;
1337 -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1338 | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1339 datarootdir=$ac_optarg ;;
1340
1341 -disable-* | --disable-*)
1342 ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1343 # Reject names that are not valid shell variable names.
1344 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1345 as_fn_error $? "invalid feature name: $ac_useropt"
1346 ac_useropt_orig=$ac_useropt
1347 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1348 case $ac_user_opts in
1349 *"
1350 "enable_$ac_useropt"
1351 "*) ;;
1352 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1353 ac_unrecognized_sep=', ';;
1354 esac
1355 eval enable_$ac_useropt=no ;;
1356
1357 -docdir | --docdir | --docdi | --doc | --do)
1358 ac_prev=docdir ;;
1359 -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1360 docdir=$ac_optarg ;;
1361
1362 -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1363 ac_prev=dvidir ;;
1364 -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1365 dvidir=$ac_optarg ;;
1366
1367 -enable-* | --enable-*)
1368 ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1369 # Reject names that are not valid shell variable names.
1370 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1371 as_fn_error $? "invalid feature name: $ac_useropt"
1372 ac_useropt_orig=$ac_useropt
1373 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1374 case $ac_user_opts in
1375 *"
1376 "enable_$ac_useropt"
1377 "*) ;;
1378 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1379 ac_unrecognized_sep=', ';;
1380 esac
1381 eval enable_$ac_useropt=\$ac_optarg ;;
1382
1383 -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1384 | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1385 | --exec | --exe | --ex)
1386 ac_prev=exec_prefix ;;
1387 -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1388 | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1389 | --exec=* | --exe=* | --ex=*)
1390 exec_prefix=$ac_optarg ;;
1391
1392 -gas | --gas | --ga | --g)
1393 # Obsolete; use --with-gas.
1394 with_gas=yes ;;
1395
1396 -help | --help | --hel | --he | -h)
1397 ac_init_help=long ;;
1398 -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1399 ac_init_help=recursive ;;
1400 -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1401 ac_init_help=short ;;
1402
1403 -host | --host | --hos | --ho)
1404 ac_prev=host_alias ;;
1405 -host=* | --host=* | --hos=* | --ho=*)
1406 host_alias=$ac_optarg ;;
1407
1408 -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1409 ac_prev=htmldir ;;
1410 -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1411 | --ht=*)
1412 htmldir=$ac_optarg ;;
1413
1414 -includedir | --includedir | --includedi | --included | --include \
1415 | --includ | --inclu | --incl | --inc)
1416 ac_prev=includedir ;;
1417 -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1418 | --includ=* | --inclu=* | --incl=* | --inc=*)
1419 includedir=$ac_optarg ;;
1420
1421 -infodir | --infodir | --infodi | --infod | --info | --inf)
1422 ac_prev=infodir ;;
1423 -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1424 infodir=$ac_optarg ;;
1425
1426 -libdir | --libdir | --libdi | --libd)
1427 ac_prev=libdir ;;
1428 -libdir=* | --libdir=* | --libdi=* | --libd=*)
1429 libdir=$ac_optarg ;;
1430
1431 -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1432 | --libexe | --libex | --libe)
1433 ac_prev=libexecdir ;;
1434 -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1435 | --libexe=* | --libex=* | --libe=*)
1436 libexecdir=$ac_optarg ;;
1437
1438 -localedir | --localedir | --localedi | --localed | --locale)
1439 ac_prev=localedir ;;
1440 -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1441 localedir=$ac_optarg ;;
1442
1443 -localstatedir | --localstatedir | --localstatedi | --localstated \
1444 | --localstate | --localstat | --localsta | --localst | --locals)
1445 ac_prev=localstatedir ;;
1446 -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1447 | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1448 localstatedir=$ac_optarg ;;
1449
1450 -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1451 ac_prev=mandir ;;
1452 -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1453 mandir=$ac_optarg ;;
1454
1455 -nfp | --nfp | --nf)
1456 # Obsolete; use --without-fp.
1457 with_fp=no ;;
1458
1459 -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1460 | --no-cr | --no-c | -n)
1461 no_create=yes ;;
1462
1463 -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1464 | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1465 no_recursion=yes ;;
1466
1467 -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1468 | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1469 | --oldin | --oldi | --old | --ol | --o)
1470 ac_prev=oldincludedir ;;
1471 -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1472 | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1473 | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1474 oldincludedir=$ac_optarg ;;
1475
1476 -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1477 ac_prev=prefix ;;
1478 -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1479 prefix=$ac_optarg ;;
1480
1481 -program-prefix | --program-prefix | --program-prefi | --program-pref \
1482 | --program-pre | --program-pr | --program-p)
1483 ac_prev=program_prefix ;;
1484 -program-prefix=* | --program-prefix=* | --program-prefi=* \
1485 | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1486 program_prefix=$ac_optarg ;;
1487
1488 -program-suffix | --program-suffix | --program-suffi | --program-suff \
1489 | --program-suf | --program-su | --program-s)
1490 ac_prev=program_suffix ;;
1491 -program-suffix=* | --program-suffix=* | --program-suffi=* \
1492 | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1493 program_suffix=$ac_optarg ;;
1494
1495 -program-transform-name | --program-transform-name \
1496 | --program-transform-nam | --program-transform-na \
1497 | --program-transform-n | --program-transform- \
1498 | --program-transform | --program-transfor \
1499 | --program-transfo | --program-transf \
1500 | --program-trans | --program-tran \
1501 | --progr-tra | --program-tr | --program-t)
1502 ac_prev=program_transform_name ;;
1503 -program-transform-name=* | --program-transform-name=* \
1504 | --program-transform-nam=* | --program-transform-na=* \
1505 | --program-transform-n=* | --program-transform-=* \
1506 | --program-transform=* | --program-transfor=* \
1507 | --program-transfo=* | --program-transf=* \
1508 | --program-trans=* | --program-tran=* \
1509 | --progr-tra=* | --program-tr=* | --program-t=*)
1510 program_transform_name=$ac_optarg ;;
1511
1512 -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1513 ac_prev=pdfdir ;;
1514 -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1515 pdfdir=$ac_optarg ;;
1516
1517 -psdir | --psdir | --psdi | --psd | --ps)
1518 ac_prev=psdir ;;
1519 -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1520 psdir=$ac_optarg ;;
1521
1522 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1523 | -silent | --silent | --silen | --sile | --sil)
1524 silent=yes ;;
1525
1526 -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1527 ac_prev=sbindir ;;
1528 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1529 | --sbi=* | --sb=*)
1530 sbindir=$ac_optarg ;;
1531
1532 -sharedstatedir | --sharedstatedir | --sharedstatedi \
1533 | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1534 | --sharedst | --shareds | --shared | --share | --shar \
1535 | --sha | --sh)
1536 ac_prev=sharedstatedir ;;
1537 -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1538 | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1539 | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1540 | --sha=* | --sh=*)
1541 sharedstatedir=$ac_optarg ;;
1542
1543 -site | --site | --sit)
1544 ac_prev=site ;;
1545 -site=* | --site=* | --sit=*)
1546 site=$ac_optarg ;;
1547
1548 -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1549 ac_prev=srcdir ;;
1550 -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1551 srcdir=$ac_optarg ;;
1552
1553 -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1554 | --syscon | --sysco | --sysc | --sys | --sy)
1555 ac_prev=sysconfdir ;;
1556 -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1557 | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1558 sysconfdir=$ac_optarg ;;
1559
1560 -target | --target | --targe | --targ | --tar | --ta | --t)
1561 ac_prev=target_alias ;;
1562 -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1563 target_alias=$ac_optarg ;;
1564
1565 -v | -verbose | --verbose | --verbos | --verbo | --verb)
1566 verbose=yes ;;
1567
1568 -version | --version | --versio | --versi | --vers | -V)
1569 ac_init_version=: ;;
1570
1571 -with-* | --with-*)
1572 ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1573 # Reject names that are not valid shell variable names.
1574 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1575 as_fn_error $? "invalid package name: $ac_useropt"
1576 ac_useropt_orig=$ac_useropt
1577 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1578 case $ac_user_opts in
1579 *"
1580 "with_$ac_useropt"
1581 "*) ;;
1582 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1583 ac_unrecognized_sep=', ';;
1584 esac
1585 eval with_$ac_useropt=\$ac_optarg ;;
1586
1587 -without-* | --without-*)
1588 ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1589 # Reject names that are not valid shell variable names.
1590 expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1591 as_fn_error $? "invalid package name: $ac_useropt"
1592 ac_useropt_orig=$ac_useropt
1593 ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1594 case $ac_user_opts in
1595 *"
1596 "with_$ac_useropt"
1597 "*) ;;
1598 *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1599 ac_unrecognized_sep=', ';;
1600 esac
1601 eval with_$ac_useropt=no ;;
1602
1603 --x)
1604 # Obsolete; use --with-x.
1605 with_x=yes ;;
1606
1607 -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1608 | --x-incl | --x-inc | --x-in | --x-i)
1609 ac_prev=x_includes ;;
1610 -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1611 | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1612 x_includes=$ac_optarg ;;
1613
1614 -x-libraries | --x-libraries | --x-librarie | --x-librari \
1615 | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1616 ac_prev=x_libraries ;;
1617 -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1618 | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1619 x_libraries=$ac_optarg ;;
1620
1621 -*) as_fn_error $? "unrecognized option: \`$ac_option'
1622 Try \`$0 --help' for more information"
1623 ;;
1624
1625 *=*)
1626 ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1627 # Reject names that are not valid shell variable names.
1628 case $ac_envvar in #(
1629 '' | [0-9]* | *[!_$as_cr_alnum]* )
1630 as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1631 esac
1632 eval $ac_envvar=\$ac_optarg
1633 export $ac_envvar ;;
1634
1635 *)
1636 # FIXME: should be removed in autoconf 3.0.
1637 $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1638 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1639 $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1640 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1641 ;;
1642
1643 esac
1644 done
1645
1646 if test -n "$ac_prev"; then
1647 ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1648 as_fn_error $? "missing argument to $ac_option"
1649 fi
1650
1651 if test -n "$ac_unrecognized_opts"; then
1652 case $enable_option_checking in
1653 no) ;;
1654 fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1655 *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1656 esac
1657 fi
1658
1659 # Check all directory arguments for consistency.
1660 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
1661 datadir sysconfdir sharedstatedir localstatedir includedir \
1662 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1663 libdir localedir mandir
1664 do
1665 eval ac_val=\$$ac_var
1666 # Remove trailing slashes.
1667 case $ac_val in
1668 */ )
1669 ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1670 eval $ac_var=\$ac_val;;
1671 esac
1672 # Be sure to have absolute directory names.
1673 case $ac_val in
1674 [\\/$]* | ?:[\\/]* ) continue;;
1675 NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1676 esac
1677 as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1678 done
1679
1680 # There might be people who depend on the old broken behavior: `$host'
1681 # used to hold the argument of --host etc.
1682 # FIXME: To remove some day.
1683 build=$build_alias
1684 host=$host_alias
1685 target=$target_alias
1686
1687 # FIXME: To remove some day.
1688 if test "x$host_alias" != x; then
1689 if test "x$build_alias" = x; then
1690 cross_compiling=maybe
1691 elif test "x$build_alias" != "x$host_alias"; then
1692 cross_compiling=yes
1693 fi
1694 fi
1695
1696 ac_tool_prefix=
1697 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1698
1699 test "$silent" = yes && exec 6>/dev/null
1700
1701
1702 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1703 ac_ls_di=`ls -di .` &&
1704 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1705 as_fn_error $? "working directory cannot be determined"
1706 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1707 as_fn_error $? "pwd does not report name of working directory"
1708
1709
1710 # Find the source files, if location was not specified.
1711 if test -z "$srcdir"; then
1712 ac_srcdir_defaulted=yes
1713 # Try the directory containing this script, then the parent directory.
1714 ac_confdir=`$as_dirname -- "$as_myself" ||
1715 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1716 X"$as_myself" : 'X\(//\)[^/]' \| \
1717 X"$as_myself" : 'X\(//\)$' \| \
1718 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1719 $as_echo X"$as_myself" |
1720 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1721 s//\1/
1722 q
1723 }
1724 /^X\(\/\/\)[^/].*/{
1725 s//\1/
1726 q
1727 }
1728 /^X\(\/\/\)$/{
1729 s//\1/
1730 q
1731 }
1732 /^X\(\/\).*/{
1733 s//\1/
1734 q
1735 }
1736 s/.*/./; q'`
1737 srcdir=$ac_confdir
1738 if test ! -r "$srcdir/$ac_unique_file"; then
1739 srcdir=..
1740 fi
1741 else
1742 ac_srcdir_defaulted=no
1743 fi
1744 if test ! -r "$srcdir/$ac_unique_file"; then
1745 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1746 as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1747 fi
1748 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1749 ac_abs_confdir=`(
1750 cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1751 pwd)`
1752 # When building in place, set srcdir=.
1753 if test "$ac_abs_confdir" = "$ac_pwd"; then
1754 srcdir=.
1755 fi
1756 # Remove unnecessary trailing slashes from srcdir.
1757 # Double slashes in file names in object file debugging info
1758 # mess up M-x gdb in Emacs.
1759 case $srcdir in
1760 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1761 esac
1762 for ac_var in $ac_precious_vars; do
1763 eval ac_env_${ac_var}_set=\${${ac_var}+set}
1764 eval ac_env_${ac_var}_value=\$${ac_var}
1765 eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1766 eval ac_cv_env_${ac_var}_value=\$${ac_var}
1767 done
1768
1769 #
1770 # Report the --help message.
1771 #
1772 if test "$ac_init_help" = "long"; then
1773 # Omit some internal or obsolete options to make the list less imposing.
1774 # This message is too long to be a string in the A/UX 3.1 sh.
1775 cat <<_ACEOF
1776 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1777
1778 Usage: $0 [OPTION]... [VAR=VALUE]...
1779
1780 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1781 VAR=VALUE. See below for descriptions of some of the useful variables.
1782
1783 Defaults for the options are specified in brackets.
1784
1785 Configuration:
1786 -h, --help display this help and exit
1787 --help=short display options specific to this package
1788 --help=recursive display the short help of all the included packages
1789 -V, --version display version information and exit
1790 -q, --quiet, --silent do not print \`checking ...' messages
1791 --cache-file=FILE cache test results in FILE [disabled]
1792 -C, --config-cache alias for \`--cache-file=config.cache'
1793 -n, --no-create do not create output files
1794 --srcdir=DIR find the sources in DIR [configure dir or \`..']
1795
1796 Installation directories:
1797 --prefix=PREFIX install architecture-independent files in PREFIX
1798 [$ac_default_prefix]
1799 --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
1800 [PREFIX]
1801
1802 By default, \`make install' will install all the files in
1803 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
1804 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1805 for instance \`--prefix=\$HOME'.
1806
1807 For better control, use the options below.
1808
1809 Fine tuning of the installation directories:
1810 --bindir=DIR user executables [EPREFIX/bin]
1811 --sbindir=DIR system admin executables [EPREFIX/sbin]
1812 --libexecdir=DIR program executables [EPREFIX/libexec]
1813 --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
1814 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
1815 --localstatedir=DIR modifiable single-machine data [PREFIX/var]
1816 --libdir=DIR object code libraries [EPREFIX/lib]
1817 --includedir=DIR C header files [PREFIX/include]
1818 --oldincludedir=DIR C header files for non-gcc [/usr/include]
1819 --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
1820 --datadir=DIR read-only architecture-independent data [DATAROOTDIR]
1821 --infodir=DIR info documentation [DATAROOTDIR/info]
1822 --localedir=DIR locale-dependent data [DATAROOTDIR/locale]
1823 --mandir=DIR man documentation [DATAROOTDIR/man]
1824 --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk]
1825 --htmldir=DIR html documentation [DOCDIR]
1826 --dvidir=DIR dvi documentation [DOCDIR]
1827 --pdfdir=DIR pdf documentation [DOCDIR]
1828 --psdir=DIR ps documentation [DOCDIR]
1829 _ACEOF
1830
1831 cat <<\_ACEOF
1832
1833 X features:
1834 --x-includes=DIR X include files are in DIR
1835 --x-libraries=DIR X library files are in DIR
1836
1837 System types:
1838 --build=BUILD configure for building on BUILD [guessed]
1839 --host=HOST cross-compile to build programs to run on HOST [BUILD]
1840 --target=TARGET configure for building compilers for TARGET [HOST]
1841 _ACEOF
1842 fi
1843
1844 if test -n "$ac_init_help"; then
1845 case $ac_init_help in
1846 short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1847 esac
1848 cat <<\_ACEOF
1849
1850 Optional Features:
1851 --disable-option-checking ignore unrecognized --enable/--with options
1852 --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
1853 --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
1854 --enable-openjdk-only suppress building custom source even if present
1855 [disabled]
1856 --enable-debug set the debug level to fastdebug (shorthand for
1857 --with-debug-level=fastdebug) [disabled]
1858 --disable-headful disable building headful support (graphical UI
1859 support) [enabled]
1860 --enable-hotspot-test-in-build
1861 run the Queens test after Hotspot build [disabled]
1862 --enable-unlimited-crypto
1863 Enable unlimited crypto policy [disabled]
1864 --enable-rmiconnector-iiop
1865 enable the JMX RMIConnector iiop transport
1866 [disabled]
1867 --disable-warnings-as-errors
1868 do not consider native warnings to be an error
1869 [enabled]
1870 --disable-debug-symbols disable generation of debug symbols [enabled]
1871 --disable-zip-debug-info
1872 disable zipping of debug-info files [enabled]
1873 --enable-native-coverage
1874 enable native compilation with code coverage
1875 data[disabled]
1876 --disable-freetype-bundling
1877 disable bundling of the freetype library with the
1878 build result [enabled on Windows or when using
1879 --with-freetype, disabled otherwise]
1880 --enable-sjavac use sjavac to do fast incremental compiles
1881 [disabled]
1882 --disable-precompiled-headers
1883 disable using precompiled headers when compiling C++
1884 [enabled]
1885 --enable-ccache enable using ccache to speed up recompilations
1886 [disabled]
1887
1888 Optional Packages:
1889 --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
1890 --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
1891 --with-target-bits build 32-bit or 64-bit binaries (for platforms that
1892 support it), e.g. --with-target-bits=32 [guessed]
1893 --with-custom-make-dir Deprecated. Option is kept for backwards
1894 compatibility and is ignored
1895 --with-jdk-variant JDK variant to build (normal) [normal]
1896 --with-jvm-interpreter JVM interpreter to build (template, cpp) [template]
1897 --with-jvm-variants JVM variants (separated by commas) to build (server,
1898 client, minimal1, kernel, zero, zeroshark, core)
1899 [server]
1900 --with-debug-level set the debug level (release, fastdebug, slowdebug,
1901 optimized (HotSpot build only)) [release]
1902 --with-devkit use this devkit for compilers, tools and resources
1903 --with-sys-root alias for --with-sysroot for backwards compatability
1904 --with-sysroot use this directory as sysroot
1905 --with-tools-dir alias for --with-toolchain-path for backwards
1906 compatibility
1907 --with-toolchain-path prepend these directories when searching for
1908 toolchain binaries (compilers etc)
1909 --with-extra-path prepend these directories to the default path
1910 --with-sdk-name use the platform SDK of the given name. [macosx]
1911 --with-conf-name use this as the name of the configuration [generated
1912 from important configuration options]
1913 --with-output-sync set make output sync type if supported by make.
1914 [recurse]
1915 --with-builddeps-conf use this configuration file for the builddeps
1916 --with-builddeps-server download and use build dependencies from this server
1917 url
1918 --with-builddeps-dir store downloaded build dependencies here
1919 [/localhome/builddeps]
1920 --with-builddeps-group chgrp the downloaded build dependencies to this
1921 group
1922 --with-cacerts-file specify alternative cacerts file
1923 --with-copyright-year Set copyright year value for build [current year]
1924 --with-milestone Deprecated. Option is kept for backwards
1925 compatibility and is ignored
1926 --with-update-version Deprecated. Option is kept for backwards
1927 compatibility and is ignored
1928 --with-user-release-suffix
1929 Deprecated. Option is kept for backwards
1930 compatibility and is ignored
1931 --with-build-number Deprecated. Option is kept for backwards
1932 compatibility and is ignored
1933 --with-version-string Set version string [calculated]
1934 --with-version-pre-base Set the base part of the version 'PRE' field
1935 (pre-release identifier) ['internal']
1936 --with-version-pre-debuglevel
1937 Set the debug level part of the version 'PRE' field
1938 (pre-release identifier) [current debug level]
1939 --with-version-opt Set version 'OPT' field (build metadata)
1940 [<timestamp>.<user>.<dirname>]
1941 --with-version-build Set version 'BUILD' field (build number) [not
1942 specified]
1943 --with-version-major Set version 'MAJOR' field (first number) [current
1944 source value]
1945 --with-version-minor Set version 'MINOR' field (second number) [current
1946 source value]
1947 --with-version-security Set version 'SECURITY' field (third number) [current
1948 source value]
1949 --with-version-patch Set version 'PATCH' field (fourth number) [not
1950 specified]
1951 --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed]
1952 --with-add-source-root for each and every source directory, look in this
1953 additional source root for the same directory; if it
1954 exists and have files in it, include it in the build
1955 --with-override-source-root
1956 for each and every source directory, look in this
1957 override source root for the same directory; if it
1958 exists, use that directory instead and ignore the
1959 directory in the original source root
1960 --with-adds-and-overrides
1961 use the subdirs 'adds' and 'overrides' in the
1962 specified directory as add-source-root and
1963 override-source-root
1964 --with-override-langtools
1965 use this langtools dir for the build
1966 --with-override-corba use this corba dir for the build
1967 --with-override-jaxp use this jaxp dir for the build
1968 --with-override-jaxws use this jaxws dir for the build
1969 --with-override-hotspot use this hotspot dir for the build
1970 --with-override-nashorn use this nashorn dir for the build
1971 --with-override-jdk use this jdk dir for the build
1972 --with-import-hotspot import hotspot binaries from this jdk image or
1973 hotspot build dist dir instead of building from
1974 source
1975 --with-toolchain-type the toolchain type (or family) to use, use '--help'
1976 to show possible values [platform dependent]
1977 --with-toolchain-version
1978 the version of the toolchain to look for, use
1979 '--help' to show possible values [platform
1980 dependent]
1981 --with-jtreg Regression Test Harness [probed]
1982 --with-extra-cflags extra flags to be used when compiling jdk c-files
1983 --with-extra-cxxflags extra flags to be used when compiling jdk c++-files
1984 --with-extra-ldflags extra flags to be used when linking jdk
1985 --with-x use the X Window System
1986 --with-cups specify prefix directory for the cups package
1987 (expecting the headers under PATH/include)
1988 --with-cups-include specify directory for the cups include files
1989 --with-freetype specify prefix directory for the freetype package
1990 (expecting the libraries under PATH/lib and the
1991 headers under PATH/include)
1992 --with-freetype-include specify directory for the freetype include files
1993 --with-freetype-lib specify directory for the freetype library
1994 --with-freetype-src specify directory with freetype sources to
1995 automatically build the library (experimental,
1996 Windows-only)
1997 --with-alsa specify prefix directory for the alsa package
1998 (expecting the libraries under PATH/lib and the
1999 headers under PATH/include)
2000 --with-alsa-include specify directory for the alsa include files
2001 --with-alsa-lib specify directory for the alsa library
2002 --with-libjpeg use libjpeg from build system or OpenJDK source
2003 (system, bundled) [bundled]
2004 --with-giflib use giflib from build system or OpenJDK source
2005 (system, bundled) [bundled]
2006 --with-lcms use lcms2 from build system or OpenJDK source
2007 (system, bundled) [bundled]
2008 --with-libpng use libpng from build system or OpenJDK source
2009 (system, bundled) [bundled]
2010 --with-zlib use zlib from build system or OpenJDK source
2011 (system, bundled) [bundled]
2012 --with-stdc++lib=<static>,<dynamic>,<default>
2013 force linking of the C++ runtime on Linux to either
2014 static or dynamic, default is static with dynamic as
2015 fallback
2016 --with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
2017 (Windows only) [probed]
2018 --with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
2019 (Windows only) [probed]
2020 --with-dxsdk Deprecated. Option is kept for backwards
2021 compatibility and is ignored
2022 --with-dxsdk-lib Deprecated. Option is kept for backwards
2023 compatibility and is ignored
2024 --with-dxsdk-include Deprecated. Option is kept for backwards
2025 compatibility and is ignored
2026 --with-num-cores number of cores in the build system, e.g.
2027 --with-num-cores=8 [probed]
2028 --with-memory-size memory (in MB) available in the build system, e.g.
2029 --with-memory-size=1024 [probed]
2030 --with-jobs number of parallel jobs to let make run [calculated
2031 based on cores and memory]
2032 --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2033 invocations of boot JDK, overriding the default
2034 values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2035 -enableassertions"
2036 --with-sjavac-server-java
2037 use this java binary for running the sjavac
2038 background server [Boot JDK java]
2039 --with-ccache-dir where to store ccache files [~/.ccache]
2040
2041 Some influential environment variables:
2042 BASENAME Override default value for BASENAME
2043 BASH Override default value for BASH
2044 CAT Override default value for CAT
2045 CHMOD Override default value for CHMOD
2046 CMP Override default value for CMP
2047 COMM Override default value for COMM
2048 CP Override default value for CP
2049 CUT Override default value for CUT
2050 DATE Override default value for DATE
2051 DIFF Override default value for DIFF
2052 DIRNAME Override default value for DIRNAME
2053 ECHO Override default value for ECHO
2054 EXPR Override default value for EXPR
2055 FILE Override default value for FILE
2056 FIND Override default value for FIND
2057 HEAD Override default value for HEAD
2058 LN Override default value for LN
2059 LS Override default value for LS
2060 MKDIR Override default value for MKDIR
2061 MKTEMP Override default value for MKTEMP
2062 MV Override default value for MV
2063 NAWK Override default value for NAWK
2064 PRINTF Override default value for PRINTF
2065 RM Override default value for RM
2066 SH Override default value for SH
2067 SORT Override default value for SORT
2068 TAIL Override default value for TAIL
2069 TAR Override default value for TAR
2070 TEE Override default value for TEE
2071 TOUCH Override default value for TOUCH
2072 TR Override default value for TR
2073 UNAME Override default value for UNAME
2074 UNIQ Override default value for UNIQ
2075 WC Override default value for WC
2076 WHICH Override default value for WHICH
2077 XARGS Override default value for XARGS
2078 AWK Override default value for AWK
2079 GREP Override default value for GREP
2080 EGREP Override default value for EGREP
2081 FGREP Override default value for FGREP
2082 SED Override default value for SED
2083 CYGPATH Override default value for CYGPATH
2084 READLINK Override default value for READLINK
2085 DF Override default value for DF
2086 SETFILE Override default value for SETFILE
2087 CPIO Override default value for CPIO
2088 UNZIP Override default value for UNZIP
2089 ZIP Override default value for ZIP
2090 LDD Override default value for LDD
2091 OTOOL Override default value for OTOOL
2092 READELF Override default value for READELF
2093 HG Override default value for HG
2094 STAT Override default value for STAT
2095 TIME Override default value for TIME
2096 DSYMUTIL Override default value for DSYMUTIL
2097 XATTR Override default value for XATTR
2098 CODESIGN Override default value for CODESIGN
2099 PKG_CONFIG path to pkg-config utility
2100 JAVA Override default value for JAVA
2101 JAVAC Override default value for JAVAC
2102 JAVAH Override default value for JAVAH
2103 JAR Override default value for JAR
2104 JARSIGNER Override default value for JARSIGNER
2105 CC C compiler command
2106 CFLAGS C compiler flags
2107 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
2108 nonstandard directory <lib dir>
2109 LIBS libraries to pass to the linker, e.g. -l<library>
2110 CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2111 you have headers in a nonstandard directory <include dir>
2112 CXX C++ compiler command
2113 CXXFLAGS C++ compiler flags
2114 CPP C preprocessor
2115 CXXCPP C++ preprocessor
2116 AS Override default value for AS
2117 AR Override default value for AR
2118 LIPO Override default value for LIPO
2119 STRIP Override default value for STRIP
2120 NM Override default value for NM
2121 GNM Override default value for GNM
2122 OBJCOPY Override default value for OBJCOPY
2123 OBJDUMP Override default value for OBJDUMP
2124 BUILD_CC Override default value for BUILD_CC
2125 BUILD_CXX Override default value for BUILD_CXX
2126 BUILD_LD Override default value for BUILD_LD
2127 JTREGEXE Override default value for JTREGEXE
2128 XMKMF Path to xmkmf, Makefile generator for X Window System
2129 FREETYPE_CFLAGS
2130 C compiler flags for FREETYPE, overriding pkg-config
2131 FREETYPE_LIBS
2132 linker flags for FREETYPE, overriding pkg-config
2133 ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2134 ALSA_LIBS linker flags for ALSA, overriding pkg-config
2135 LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2136 LCMS_LIBS linker flags for LCMS, overriding pkg-config
2137 PNG_CFLAGS C compiler flags for PNG, overriding pkg-config
2138 PNG_LIBS linker flags for PNG, overriding pkg-config
2139 LIBFFI_CFLAGS
2140 C compiler flags for LIBFFI, overriding pkg-config
2141 LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2142 CCACHE Override default value for CCACHE
2143
2144 Use these variables to override the choices made by `configure' or to help
2145 it to find libraries and programs with nonstandard names/locations.
2146
2147 Report bugs to <build-dev@openjdk.java.net>.
2148 OpenJDK home page: <http://openjdk.java.net>.
2149 _ACEOF
2150 ac_status=$?
2151 fi
2152
2153 if test "$ac_init_help" = "recursive"; then
2154 # If there are subdirs, report their specific --help.
2155 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2156 test -d "$ac_dir" ||
2157 { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2158 continue
2159 ac_builddir=.
2160
2161 case "$ac_dir" in
2162 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2163 *)
2164 ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2165 # A ".." for each directory in $ac_dir_suffix.
2166 ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2167 case $ac_top_builddir_sub in
2168 "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2169 *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2170 esac ;;
2171 esac
2172 ac_abs_top_builddir=$ac_pwd
2173 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2174 # for backward compatibility:
2175 ac_top_builddir=$ac_top_build_prefix
2176
2177 case $srcdir in
2178 .) # We are building in place.
2179 ac_srcdir=.
2180 ac_top_srcdir=$ac_top_builddir_sub
2181 ac_abs_top_srcdir=$ac_pwd ;;
2182 [\\/]* | ?:[\\/]* ) # Absolute name.
2183 ac_srcdir=$srcdir$ac_dir_suffix;
2184 ac_top_srcdir=$srcdir
2185 ac_abs_top_srcdir=$srcdir ;;
2186 *) # Relative name.
2187 ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2188 ac_top_srcdir=$ac_top_build_prefix$srcdir
2189 ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2190 esac
2191 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2192
2193 cd "$ac_dir" || { ac_status=$?; continue; }
2194 # Check for guested configure.
2195 if test -f "$ac_srcdir/configure.gnu"; then
2196 echo &&
2197 $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2198 elif test -f "$ac_srcdir/configure"; then
2199 echo &&
2200 $SHELL "$ac_srcdir/configure" --help=recursive
2201 else
2202 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2203 fi || ac_status=$?
2204 cd "$ac_pwd" || { ac_status=$?; break; }
2205 done
2206 fi
2207
2208 test -n "$ac_init_help" && exit $ac_status
2209 if $ac_init_version; then
2210 cat <<\_ACEOF
2211 OpenJDK configure jdk9
2212 generated by GNU Autoconf 2.69
2213
2214 Copyright (C) 2012 Free Software Foundation, Inc.
2215 This configure script is free software; the Free Software Foundation
2216 gives unlimited permission to copy, distribute and modify it.
2217 _ACEOF
2218 exit
2219 fi
2220
2221 ## ------------------------ ##
2222 ## Autoconf initialization. ##
2223 ## ------------------------ ##
2224
2225 # ac_fn_c_try_compile LINENO
2226 # --------------------------
2227 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2228 ac_fn_c_try_compile ()
2229 {
2230 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2231 rm -f conftest.$ac_objext
2232 if { { ac_try="$ac_compile"
2233 case "(($ac_try" in
2234 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2235 *) ac_try_echo=$ac_try;;
2236 esac
2237 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2238 $as_echo "$ac_try_echo"; } >&5
2239 (eval "$ac_compile") 2>conftest.err
2240 ac_status=$?
2241 if test -s conftest.err; then
2242 grep -v '^ *+' conftest.err >conftest.er1
2243 cat conftest.er1 >&5
2244 mv -f conftest.er1 conftest.err
2245 fi
2246 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2247 test $ac_status = 0; } && {
2248 test -z "$ac_c_werror_flag" ||
2249 test ! -s conftest.err
2250 } && test -s conftest.$ac_objext; then :
2251 ac_retval=0
2252 else
2253 $as_echo "$as_me: failed program was:" >&5
2254 sed 's/^/| /' conftest.$ac_ext >&5
2255
2256 ac_retval=1
2257 fi
2258 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2259 as_fn_set_status $ac_retval
2260
2261 } # ac_fn_c_try_compile
2262
2263 # ac_fn_cxx_try_compile LINENO
2264 # ----------------------------
2265 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2266 ac_fn_cxx_try_compile ()
2267 {
2268 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2269 rm -f conftest.$ac_objext
2270 if { { ac_try="$ac_compile"
2271 case "(($ac_try" in
2272 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2273 *) ac_try_echo=$ac_try;;
2274 esac
2275 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2276 $as_echo "$ac_try_echo"; } >&5
2277 (eval "$ac_compile") 2>conftest.err
2278 ac_status=$?
2279 if test -s conftest.err; then
2280 grep -v '^ *+' conftest.err >conftest.er1
2281 cat conftest.er1 >&5
2282 mv -f conftest.er1 conftest.err
2283 fi
2284 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2285 test $ac_status = 0; } && {
2286 test -z "$ac_cxx_werror_flag" ||
2287 test ! -s conftest.err
2288 } && test -s conftest.$ac_objext; then :
2289 ac_retval=0
2290 else
2291 $as_echo "$as_me: failed program was:" >&5
2292 sed 's/^/| /' conftest.$ac_ext >&5
2293
2294 ac_retval=1
2295 fi
2296 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2297 as_fn_set_status $ac_retval
2298
2299 } # ac_fn_cxx_try_compile
2300
2301 # ac_fn_c_try_cpp LINENO
2302 # ----------------------
2303 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2304 ac_fn_c_try_cpp ()
2305 {
2306 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2307 if { { ac_try="$ac_cpp conftest.$ac_ext"
2308 case "(($ac_try" in
2309 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2310 *) ac_try_echo=$ac_try;;
2311 esac
2312 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2313 $as_echo "$ac_try_echo"; } >&5
2314 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2315 ac_status=$?
2316 if test -s conftest.err; then
2317 grep -v '^ *+' conftest.err >conftest.er1
2318 cat conftest.er1 >&5
2319 mv -f conftest.er1 conftest.err
2320 fi
2321 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2322 test $ac_status = 0; } > conftest.i && {
2323 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2324 test ! -s conftest.err
2325 }; then :
2326 ac_retval=0
2327 else
2328 $as_echo "$as_me: failed program was:" >&5
2329 sed 's/^/| /' conftest.$ac_ext >&5
2330
2331 ac_retval=1
2332 fi
2333 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2334 as_fn_set_status $ac_retval
2335
2336 } # ac_fn_c_try_cpp
2337
2338 # ac_fn_cxx_try_cpp LINENO
2339 # ------------------------
2340 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2341 ac_fn_cxx_try_cpp ()
2342 {
2343 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2344 if { { ac_try="$ac_cpp conftest.$ac_ext"
2345 case "(($ac_try" in
2346 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2347 *) ac_try_echo=$ac_try;;
2348 esac
2349 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2350 $as_echo "$ac_try_echo"; } >&5
2351 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2352 ac_status=$?
2353 if test -s conftest.err; then
2354 grep -v '^ *+' conftest.err >conftest.er1
2355 cat conftest.er1 >&5
2356 mv -f conftest.er1 conftest.err
2357 fi
2358 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2359 test $ac_status = 0; } > conftest.i && {
2360 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2361 test ! -s conftest.err
2362 }; then :
2363 ac_retval=0
2364 else
2365 $as_echo "$as_me: failed program was:" >&5
2366 sed 's/^/| /' conftest.$ac_ext >&5
2367
2368 ac_retval=1
2369 fi
2370 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2371 as_fn_set_status $ac_retval
2372
2373 } # ac_fn_cxx_try_cpp
2374
2375 # ac_fn_c_try_link LINENO
2376 # -----------------------
2377 # Try to link conftest.$ac_ext, and return whether this succeeded.
2378 ac_fn_c_try_link ()
2379 {
2380 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2381 rm -f conftest.$ac_objext conftest$ac_exeext
2382 if { { ac_try="$ac_link"
2383 case "(($ac_try" in
2384 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2385 *) ac_try_echo=$ac_try;;
2386 esac
2387 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2388 $as_echo "$ac_try_echo"; } >&5
2389 (eval "$ac_link") 2>conftest.err
2390 ac_status=$?
2391 if test -s conftest.err; then
2392 grep -v '^ *+' conftest.err >conftest.er1
2393 cat conftest.er1 >&5
2394 mv -f conftest.er1 conftest.err
2395 fi
2396 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2397 test $ac_status = 0; } && {
2398 test -z "$ac_c_werror_flag" ||
2399 test ! -s conftest.err
2400 } && test -s conftest$ac_exeext && {
2401 test "$cross_compiling" = yes ||
2402 test -x conftest$ac_exeext
2403 }; then :
2404 ac_retval=0
2405 else
2406 $as_echo "$as_me: failed program was:" >&5
2407 sed 's/^/| /' conftest.$ac_ext >&5
2408
2409 ac_retval=1
2410 fi
2411 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2412 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2413 # interfere with the next link command; also delete a directory that is
2414 # left behind by Apple's compiler. We do this before executing the actions.
2415 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2416 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2417 as_fn_set_status $ac_retval
2418
2419 } # ac_fn_c_try_link
2420
2421 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2422 # ---------------------------------------------------------
2423 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2424 # the include files in INCLUDES and setting the cache variable VAR
2425 # accordingly.
2426 ac_fn_cxx_check_header_mongrel ()
2427 {
2428 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2429 if eval \${$3+:} false; then :
2430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2431 $as_echo_n "checking for $2... " >&6; }
2432 if eval \${$3+:} false; then :
2433 $as_echo_n "(cached) " >&6
2434 fi
2435 eval ac_res=\$$3
2436 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2437 $as_echo "$ac_res" >&6; }
2438 else
2439 # Is the header compilable?
2440 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2441 $as_echo_n "checking $2 usability... " >&6; }
2442 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2443 /* end confdefs.h. */
2444 $4
2445 #include <$2>
2446 _ACEOF
2447 if ac_fn_cxx_try_compile "$LINENO"; then :
2448 ac_header_compiler=yes
2449 else
2450 ac_header_compiler=no
2451 fi
2452 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2453 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2454 $as_echo "$ac_header_compiler" >&6; }
2455
2456 # Is the header present?
2457 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2458 $as_echo_n "checking $2 presence... " >&6; }
2459 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2460 /* end confdefs.h. */
2461 #include <$2>
2462 _ACEOF
2463 if ac_fn_cxx_try_cpp "$LINENO"; then :
2464 ac_header_preproc=yes
2465 else
2466 ac_header_preproc=no
2467 fi
2468 rm -f conftest.err conftest.i conftest.$ac_ext
2469 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2470 $as_echo "$ac_header_preproc" >&6; }
2471
2472 # So? What about this header?
2473 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2474 yes:no: )
2475 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2476 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2477 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2478 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2479 ;;
2480 no:yes:* )
2481 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2482 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2483 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
2484 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
2485 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2486 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2487 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
2488 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
2489 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2490 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2491 ( $as_echo "## ----------------------------------------- ##
2492 ## Report this to build-dev@openjdk.java.net ##
2493 ## ----------------------------------------- ##"
2494 ) | sed "s/^/$as_me: WARNING: /" >&2
2495 ;;
2496 esac
2497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2498 $as_echo_n "checking for $2... " >&6; }
2499 if eval \${$3+:} false; then :
2500 $as_echo_n "(cached) " >&6
2501 else
2502 eval "$3=\$ac_header_compiler"
2503 fi
2504 eval ac_res=\$$3
2505 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2506 $as_echo "$ac_res" >&6; }
2507 fi
2508 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2509
2510 } # ac_fn_cxx_check_header_mongrel
2511
2512 # ac_fn_cxx_try_run LINENO
2513 # ------------------------
2514 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2515 # that executables *can* be run.
2516 ac_fn_cxx_try_run ()
2517 {
2518 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2519 if { { ac_try="$ac_link"
2520 case "(($ac_try" in
2521 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2522 *) ac_try_echo=$ac_try;;
2523 esac
2524 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2525 $as_echo "$ac_try_echo"; } >&5
2526 (eval "$ac_link") 2>&5
2527 ac_status=$?
2528 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2529 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2530 { { case "(($ac_try" in
2531 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2532 *) ac_try_echo=$ac_try;;
2533 esac
2534 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2535 $as_echo "$ac_try_echo"; } >&5
2536 (eval "$ac_try") 2>&5
2537 ac_status=$?
2538 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2539 test $ac_status = 0; }; }; then :
2540 ac_retval=0
2541 else
2542 $as_echo "$as_me: program exited with status $ac_status" >&5
2543 $as_echo "$as_me: failed program was:" >&5
2544 sed 's/^/| /' conftest.$ac_ext >&5
2545
2546 ac_retval=$ac_status
2547 fi
2548 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2549 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2550 as_fn_set_status $ac_retval
2551
2552 } # ac_fn_cxx_try_run
2553
2554 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2555 # ---------------------------------------------------------
2556 # Tests whether HEADER exists and can be compiled using the include files in
2557 # INCLUDES, setting the cache variable VAR accordingly.
2558 ac_fn_cxx_check_header_compile ()
2559 {
2560 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2562 $as_echo_n "checking for $2... " >&6; }
2563 if eval \${$3+:} false; then :
2564 $as_echo_n "(cached) " >&6
2565 else
2566 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2567 /* end confdefs.h. */
2568 $4
2569 #include <$2>
2570 _ACEOF
2571 if ac_fn_cxx_try_compile "$LINENO"; then :
2572 eval "$3=yes"
2573 else
2574 eval "$3=no"
2575 fi
2576 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2577 fi
2578 eval ac_res=\$$3
2579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2580 $as_echo "$ac_res" >&6; }
2581 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2582
2583 } # ac_fn_cxx_check_header_compile
2584
2585 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2586 # ----------------------------------------------
2587 # Tries to find the compile-time value of EXPR in a program that includes
2588 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2589 # computed
2590 ac_fn_cxx_compute_int ()
2591 {
2592 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2593 if test "$cross_compiling" = yes; then
2594 # Depending upon the size, compute the lo and hi bounds.
2595 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2596 /* end confdefs.h. */
2597 $4
2598 int
2599 main ()
2600 {
2601 static int test_array [1 - 2 * !(($2) >= 0)];
2602 test_array [0] = 0;
2603 return test_array [0];
2604
2605 ;
2606 return 0;
2607 }
2608 _ACEOF
2609 if ac_fn_cxx_try_compile "$LINENO"; then :
2610 ac_lo=0 ac_mid=0
2611 while :; do
2612 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2613 /* end confdefs.h. */
2614 $4
2615 int
2616 main ()
2617 {
2618 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2619 test_array [0] = 0;
2620 return test_array [0];
2621
2622 ;
2623 return 0;
2624 }
2625 _ACEOF
2626 if ac_fn_cxx_try_compile "$LINENO"; then :
2627 ac_hi=$ac_mid; break
2628 else
2629 as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2630 if test $ac_lo -le $ac_mid; then
2631 ac_lo= ac_hi=
2632 break
2633 fi
2634 as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2635 fi
2636 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2637 done
2638 else
2639 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2640 /* end confdefs.h. */
2641 $4
2642 int
2643 main ()
2644 {
2645 static int test_array [1 - 2 * !(($2) < 0)];
2646 test_array [0] = 0;
2647 return test_array [0];
2648
2649 ;
2650 return 0;
2651 }
2652 _ACEOF
2653 if ac_fn_cxx_try_compile "$LINENO"; then :
2654 ac_hi=-1 ac_mid=-1
2655 while :; do
2656 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2657 /* end confdefs.h. */
2658 $4
2659 int
2660 main ()
2661 {
2662 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2663 test_array [0] = 0;
2664 return test_array [0];
2665
2666 ;
2667 return 0;
2668 }
2669 _ACEOF
2670 if ac_fn_cxx_try_compile "$LINENO"; then :
2671 ac_lo=$ac_mid; break
2672 else
2673 as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2674 if test $ac_mid -le $ac_hi; then
2675 ac_lo= ac_hi=
2676 break
2677 fi
2678 as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2679 fi
2680 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2681 done
2682 else
2683 ac_lo= ac_hi=
2684 fi
2685 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2686 fi
2687 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2688 # Binary search between lo and hi bounds.
2689 while test "x$ac_lo" != "x$ac_hi"; do
2690 as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2691 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2692 /* end confdefs.h. */
2693 $4
2694 int
2695 main ()
2696 {
2697 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2698 test_array [0] = 0;
2699 return test_array [0];
2700
2701 ;
2702 return 0;
2703 }
2704 _ACEOF
2705 if ac_fn_cxx_try_compile "$LINENO"; then :
2706 ac_hi=$ac_mid
2707 else
2708 as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2709 fi
2710 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2711 done
2712 case $ac_lo in #((
2713 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2714 '') ac_retval=1 ;;
2715 esac
2716 else
2717 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2718 /* end confdefs.h. */
2719 $4
2720 static long int longval () { return $2; }
2721 static unsigned long int ulongval () { return $2; }
2722 #include <stdio.h>
2723 #include <stdlib.h>
2724 int
2725 main ()
2726 {
2727
2728 FILE *f = fopen ("conftest.val", "w");
2729 if (! f)
2730 return 1;
2731 if (($2) < 0)
2732 {
2733 long int i = longval ();
2734 if (i != ($2))
2735 return 1;
2736 fprintf (f, "%ld", i);
2737 }
2738 else
2739 {
2740 unsigned long int i = ulongval ();
2741 if (i != ($2))
2742 return 1;
2743 fprintf (f, "%lu", i);
2744 }
2745 /* Do not output a trailing newline, as this causes \r\n confusion
2746 on some platforms. */
2747 return ferror (f) || fclose (f) != 0;
2748
2749 ;
2750 return 0;
2751 }
2752 _ACEOF
2753 if ac_fn_cxx_try_run "$LINENO"; then :
2754 echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2755 else
2756 ac_retval=1
2757 fi
2758 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2759 conftest.$ac_objext conftest.beam conftest.$ac_ext
2760 rm -f conftest.val
2761
2762 fi
2763 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2764 as_fn_set_status $ac_retval
2765
2766 } # ac_fn_cxx_compute_int
2767
2768 # ac_fn_cxx_try_link LINENO
2769 # -------------------------
2770 # Try to link conftest.$ac_ext, and return whether this succeeded.
2771 ac_fn_cxx_try_link ()
2772 {
2773 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2774 rm -f conftest.$ac_objext conftest$ac_exeext
2775 if { { ac_try="$ac_link"
2776 case "(($ac_try" in
2777 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2778 *) ac_try_echo=$ac_try;;
2779 esac
2780 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2781 $as_echo "$ac_try_echo"; } >&5
2782 (eval "$ac_link") 2>conftest.err
2783 ac_status=$?
2784 if test -s conftest.err; then
2785 grep -v '^ *+' conftest.err >conftest.er1
2786 cat conftest.er1 >&5
2787 mv -f conftest.er1 conftest.err
2788 fi
2789 $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2790 test $ac_status = 0; } && {
2791 test -z "$ac_cxx_werror_flag" ||
2792 test ! -s conftest.err
2793 } && test -s conftest$ac_exeext && {
2794 test "$cross_compiling" = yes ||
2795 test -x conftest$ac_exeext
2796 }; then :
2797 ac_retval=0
2798 else
2799 $as_echo "$as_me: failed program was:" >&5
2800 sed 's/^/| /' conftest.$ac_ext >&5
2801
2802 ac_retval=1
2803 fi
2804 # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2805 # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2806 # interfere with the next link command; also delete a directory that is
2807 # left behind by Apple's compiler. We do this before executing the actions.
2808 rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2809 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2810 as_fn_set_status $ac_retval
2811
2812 } # ac_fn_cxx_try_link
2813
2814 # ac_fn_cxx_check_func LINENO FUNC VAR
2815 # ------------------------------------
2816 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2817 ac_fn_cxx_check_func ()
2818 {
2819 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2821 $as_echo_n "checking for $2... " >&6; }
2822 if eval \${$3+:} false; then :
2823 $as_echo_n "(cached) " >&6
2824 else
2825 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2826 /* end confdefs.h. */
2827 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2828 For example, HP-UX 11i <limits.h> declares gettimeofday. */
2829 #define $2 innocuous_$2
2830
2831 /* System header to define __stub macros and hopefully few prototypes,
2832 which can conflict with char $2 (); below.
2833 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2834 <limits.h> exists even on freestanding compilers. */
2835
2836 #ifdef __STDC__
2837 # include <limits.h>
2838 #else
2839 # include <assert.h>
2840 #endif
2841
2842 #undef $2
2843
2844 /* Override any GCC internal prototype to avoid an error.
2845 Use char because int might match the return type of a GCC
2846 builtin and then its argument prototype would still apply. */
2847 #ifdef __cplusplus
2848 extern "C"
2849 #endif
2850 char $2 ();
2851 /* The GNU C library defines this for functions which it implements
2852 to always fail with ENOSYS. Some functions are actually named
2853 something starting with __ and the normal name is an alias. */
2854 #if defined __stub_$2 || defined __stub___$2
2855 choke me
2856 #endif
2857
2858 int
2859 main ()
2860 {
2861 return $2 ();
2862 ;
2863 return 0;
2864 }
2865 _ACEOF
2866 if ac_fn_cxx_try_link "$LINENO"; then :
2867 eval "$3=yes"
2868 else
2869 eval "$3=no"
2870 fi
2871 rm -f core conftest.err conftest.$ac_objext \
2872 conftest$ac_exeext conftest.$ac_ext
2873 fi
2874 eval ac_res=\$$3
2875 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2876 $as_echo "$ac_res" >&6; }
2877 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2878
2879 } # ac_fn_cxx_check_func
2880
2881 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2882 # -------------------------------------------------------
2883 # Tests whether HEADER exists and can be compiled using the include files in
2884 # INCLUDES, setting the cache variable VAR accordingly.
2885 ac_fn_c_check_header_compile ()
2886 {
2887 as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2888 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2889 $as_echo_n "checking for $2... " >&6; }
2890 if eval \${$3+:} false; then :
2891 $as_echo_n "(cached) " >&6
2892 else
2893 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2894 /* end confdefs.h. */
2895 $4
2896 #include <$2>
2897 _ACEOF
2898 if ac_fn_c_try_compile "$LINENO"; then :
2899 eval "$3=yes"
2900 else
2901 eval "$3=no"
2902 fi
2903 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2904 fi
2905 eval ac_res=\$$3
2906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2907 $as_echo "$ac_res" >&6; }
2908 eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2909
2910 } # ac_fn_c_check_header_compile
2911 cat >config.log <<_ACEOF
2912 This file contains any messages produced by compilers while
2913 running configure, to aid debugging if configure makes a mistake.
2914
2915 It was created by OpenJDK $as_me jdk9, which was
2916 generated by GNU Autoconf 2.69. Invocation command line was
2917
2918 $ $0 $@
2919
2920 _ACEOF
2921 exec 5>>config.log
2922 {
2923 cat <<_ASUNAME
2924 ## --------- ##
2925 ## Platform. ##
2926 ## --------- ##
2927
2928 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2929 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2930 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2931 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2932 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2933
2934 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2935 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
2936
2937 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
2938 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
2939 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2940 /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
2941 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
2942 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
2943 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
2944
2945 _ASUNAME
2946
2947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2948 for as_dir in $PATH
2949 do
2950 IFS=$as_save_IFS
2951 test -z "$as_dir" && as_dir=.
2952 $as_echo "PATH: $as_dir"
2953 done
2954 IFS=$as_save_IFS
2955
2956 } >&5
2957
2958 cat >&5 <<_ACEOF
2959
2960
2961 ## ----------- ##
2962 ## Core tests. ##
2963 ## ----------- ##
2964
2965 _ACEOF
2966
2967
2968 # Keep a trace of the command line.
2969 # Strip out --no-create and --no-recursion so they do not pile up.
2970 # Strip out --silent because we don't want to record it for future runs.
2971 # Also quote any args containing shell meta-characters.
2972 # Make two passes to allow for proper duplicate-argument suppression.
2973 ac_configure_args=
2974 ac_configure_args0=
2975 ac_configure_args1=
2976 ac_must_keep_next=false
2977 for ac_pass in 1 2
2978 do
2979 for ac_arg
2980 do
2981 case $ac_arg in
2982 -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2983 -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2984 | -silent | --silent | --silen | --sile | --sil)
2985 continue ;;
2986 *\'*)
2987 ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2988 esac
2989 case $ac_pass in
2990 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2991 2)
2992 as_fn_append ac_configure_args1 " '$ac_arg'"
2993 if test $ac_must_keep_next = true; then
2994 ac_must_keep_next=false # Got value, back to normal.
2995 else
2996 case $ac_arg in
2997 *=* | --config-cache | -C | -disable-* | --disable-* \
2998 | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2999 | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3000 | -with-* | --with-* | -without-* | --without-* | --x)
3001 case "$ac_configure_args0 " in
3002 "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3003 esac
3004 ;;
3005 -* ) ac_must_keep_next=true ;;
3006 esac
3007 fi
3008 as_fn_append ac_configure_args " '$ac_arg'"
3009 ;;
3010 esac
3011 done
3012 done
3013 { ac_configure_args0=; unset ac_configure_args0;}
3014 { ac_configure_args1=; unset ac_configure_args1;}
3015
3016 # When interrupted or exit'd, cleanup temporary files, and complete
3017 # config.log. We remove comments because anyway the quotes in there
3018 # would cause problems or look ugly.
3019 # WARNING: Use '\'' to represent an apostrophe within the trap.
3020 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3021 trap 'exit_status=$?
3022 # Save into config.log some information that might help in debugging.
3023 {
3024 echo
3025
3026 $as_echo "## ---------------- ##
3027 ## Cache variables. ##
3028 ## ---------------- ##"
3029 echo
3030 # The following way of writing the cache mishandles newlines in values,
3031 (
3032 for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3033 eval ac_val=\$$ac_var
3034 case $ac_val in #(
3035 *${as_nl}*)
3036 case $ac_var in #(
3037 *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3038 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3039 esac
3040 case $ac_var in #(
3041 _ | IFS | as_nl) ;; #(
3042 BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3043 *) { eval $ac_var=; unset $ac_var;} ;;
3044 esac ;;
3045 esac
3046 done
3047 (set) 2>&1 |
3048 case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3049 *${as_nl}ac_space=\ *)
3050 sed -n \
3051 "s/'\''/'\''\\\\'\'''\''/g;
3052 s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3053 ;; #(
3054 *)
3055 sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3056 ;;
3057 esac |
3058 sort
3059 )
3060 echo
3061
3062 $as_echo "## ----------------- ##
3063 ## Output variables. ##
3064 ## ----------------- ##"
3065 echo
3066 for ac_var in $ac_subst_vars
3067 do
3068 eval ac_val=\$$ac_var
3069 case $ac_val in
3070 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3071 esac
3072 $as_echo "$ac_var='\''$ac_val'\''"
3073 done | sort
3074 echo
3075
3076 if test -n "$ac_subst_files"; then
3077 $as_echo "## ------------------- ##
3078 ## File substitutions. ##
3079 ## ------------------- ##"
3080 echo
3081 for ac_var in $ac_subst_files
3082 do
3083 eval ac_val=\$$ac_var
3084 case $ac_val in
3085 *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3086 esac
3087 $as_echo "$ac_var='\''$ac_val'\''"
3088 done | sort
3089 echo
3090 fi
3091
3092 if test -s confdefs.h; then
3093 $as_echo "## ----------- ##
3094 ## confdefs.h. ##
3095 ## ----------- ##"
3096 echo
3097 cat confdefs.h
3098 echo
3099 fi
3100 test "$ac_signal" != 0 &&
3101 $as_echo "$as_me: caught signal $ac_signal"
3102 $as_echo "$as_me: exit $exit_status"
3103 } >&5
3104 rm -f core *.core core.conftest.* &&
3105 rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3106 exit $exit_status
3107 ' 0
3108 for ac_signal in 1 2 13 15; do
3109 trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3110 done
3111 ac_signal=0
3112
3113 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3114 rm -f -r conftest* confdefs.h
3115
3116 $as_echo "/* confdefs.h */" > confdefs.h
3117
3118 # Predefined preprocessor variables.
3119
3120 cat >>confdefs.h <<_ACEOF
3121 #define PACKAGE_NAME "$PACKAGE_NAME"
3122 _ACEOF
3123
3124 cat >>confdefs.h <<_ACEOF
3125 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3126 _ACEOF
3127
3128 cat >>confdefs.h <<_ACEOF
3129 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3130 _ACEOF
3131
3132 cat >>confdefs.h <<_ACEOF
3133 #define PACKAGE_STRING "$PACKAGE_STRING"
3134 _ACEOF
3135
3136 cat >>confdefs.h <<_ACEOF
3137 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3138 _ACEOF
3139
3140 cat >>confdefs.h <<_ACEOF
3141 #define PACKAGE_URL "$PACKAGE_URL"
3142 _ACEOF
3143
3144
3145 # Let the site file select an alternate cache file if it wants to.
3146 # Prefer an explicitly selected file to automatically selected ones.
3147 ac_site_file1=NONE
3148 ac_site_file2=NONE
3149 if test -n "$CONFIG_SITE"; then
3150 # We do not want a PATH search for config.site.
3151 case $CONFIG_SITE in #((
3152 -*) ac_site_file1=./$CONFIG_SITE;;
3153 */*) ac_site_file1=$CONFIG_SITE;;
3154 *) ac_site_file1=./$CONFIG_SITE;;
3155 esac
3156 elif test "x$prefix" != xNONE; then
3157 ac_site_file1=$prefix/share/config.site
3158 ac_site_file2=$prefix/etc/config.site
3159 else
3160 ac_site_file1=$ac_default_prefix/share/config.site
3161 ac_site_file2=$ac_default_prefix/etc/config.site
3162 fi
3163 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3164 do
3165 test "x$ac_site_file" = xNONE && continue
3166 if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3167 { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3168 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3169 sed 's/^/| /' "$ac_site_file" >&5
3170 . "$ac_site_file" \
3171 || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3172 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3173 as_fn_error $? "failed to load site script $ac_site_file
3174 See \`config.log' for more details" "$LINENO" 5; }
3175 fi
3176 done
3177
3178 if test -r "$cache_file"; then
3179 # Some versions of bash will fail to source /dev/null (special files
3180 # actually), so we avoid doing that. DJGPP emulates it as a regular file.
3181 if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3182 { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3183 $as_echo "$as_me: loading cache $cache_file" >&6;}
3184 case $cache_file in
3185 [\\/]* | ?:[\\/]* ) . "$cache_file";;
3186 *) . "./$cache_file";;
3187 esac
3188 fi
3189 else
3190 { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3191 $as_echo "$as_me: creating cache $cache_file" >&6;}
3192 >$cache_file
3193 fi
3194
3195 # Check that the precious variables saved in the cache have kept the same
3196 # value.
3197 ac_cache_corrupted=false
3198 for ac_var in $ac_precious_vars; do
3199 eval ac_old_set=\$ac_cv_env_${ac_var}_set
3200 eval ac_new_set=\$ac_env_${ac_var}_set
3201 eval ac_old_val=\$ac_cv_env_${ac_var}_value
3202 eval ac_new_val=\$ac_env_${ac_var}_value
3203 case $ac_old_set,$ac_new_set in
3204 set,)
3205 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3206 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3207 ac_cache_corrupted=: ;;
3208 ,set)
3209 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3210 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3211 ac_cache_corrupted=: ;;
3212 ,);;
3213 *)
3214 if test "x$ac_old_val" != "x$ac_new_val"; then
3215 # differences in whitespace do not lead to failure.
3216 ac_old_val_w=`echo x $ac_old_val`
3217 ac_new_val_w=`echo x $ac_new_val`
3218 if test "$ac_old_val_w" != "$ac_new_val_w"; then
3219 { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3220 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3221 ac_cache_corrupted=:
3222 else
3223 { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3224 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3225 eval $ac_var=\$ac_old_val
3226 fi
3227 { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
3228 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
3229 { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
3230 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
3231 fi;;
3232 esac
3233 # Pass precious variables to config.status.
3234 if test "$ac_new_set" = set; then
3235 case $ac_new_val in
3236 *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3237 *) ac_arg=$ac_var=$ac_new_val ;;
3238 esac
3239 case " $ac_configure_args " in
3240 *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
3241 *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3242 esac
3243 fi
3244 done
3245 if $ac_cache_corrupted; then
3246 { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3247 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3248 { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3249 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3250 as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3251 fi
3252 ## -------------------- ##
3253 ## Main body of script. ##
3254 ## -------------------- ##
3255
3256 ac_ext=c
3257 ac_cpp='$CPP $CPPFLAGS'
3258 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3259 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3260 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3261
3262
3263
3264 ac_aux_dir=
3265 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3266 if test -f "$ac_dir/install-sh"; then
3267 ac_aux_dir=$ac_dir
3268 ac_install_sh="$ac_aux_dir/install-sh -c"
3269 break
3270 elif test -f "$ac_dir/install.sh"; then
3271 ac_aux_dir=$ac_dir
3272 ac_install_sh="$ac_aux_dir/install.sh -c"
3273 break
3274 elif test -f "$ac_dir/shtool"; then
3275 ac_aux_dir=$ac_dir
3276 ac_install_sh="$ac_aux_dir/shtool install -c"
3277 break
3278 fi
3279 done
3280 if test -z "$ac_aux_dir"; then
3281 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
3282 fi
3283
3284 # These three variables are undocumented and unsupported,
3285 # and are intended to be withdrawn in a future Autoconf release.
3286 # They can cause serious problems if a builder's source tree is in a directory
3287 # whose full name contains unusual characters.
3288 ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
3289 ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
3290 ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
3291
3292
3293 # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
3294
3295 #
3296 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3297 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3298 #
3299 # This code is free software; you can redistribute it and/or modify it
3300 # under the terms of the GNU General Public License version 2 only, as
3301 # published by the Free Software Foundation. Oracle designates this
3302 # particular file as subject to the "Classpath" exception as provided
3303 # by Oracle in the LICENSE file that accompanied this code.
3304 #
3305 # This code is distributed in the hope that it will be useful, but WITHOUT
3306 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3307 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3308 # version 2 for more details (a copy is included in the LICENSE file that
3309 # accompanied this code).
3310 #
3311 # You should have received a copy of the GNU General Public License version
3312 # 2 along with this work; if not, write to the Free Software Foundation,
3313 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3314 #
3315 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3316 # or visit www.oracle.com if you need additional information or have any
3317 # questions.
3318 #
3319
3320 #
3321 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3322 #
3323 # This program is free software; you can redistribute it and/or modify
3324 # it under the terms of the GNU General Public License as published by
3325 # the Free Software Foundation; either version 2 of the License, or
3326 # (at your option) any later version.
3327 #
3328 # This program is distributed in the hope that it will be useful, but
3329 # WITHOUT ANY WARRANTY; without even the implied warranty of
3330 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3331 # General Public License for more details.
3332 #
3333 # You should have received a copy of the GNU General Public License
3334 # along with this program; if not, write to the Free Software
3335 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3336 #
3337 # As a special exception to the GNU General Public License, if you
3338 # distribute this file as part of a program that contains a
3339 # configuration script generated by Autoconf, you may include it under
3340 # the same distribution terms that you use for the rest of that program.
3341
3342 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3343 # ----------------------------------
3344 # PKG_PROG_PKG_CONFIG
3345
3346 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3347 #
3348 # Check to see whether a particular set of modules exists. Similar
3349 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3350 #
3351 #
3352 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3353 # this or PKG_CHECK_MODULES is called, or make sure to call
3354 # PKG_CHECK_EXISTS manually
3355 # --------------------------------------------------------------
3356
3357
3358
3359 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3360 # ---------------------------------------------
3361 # _PKG_CONFIG
3362
3363 # _PKG_SHORT_ERRORS_SUPPORTED
3364 # -----------------------------
3365 # _PKG_SHORT_ERRORS_SUPPORTED
3366
3367
3368 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3369 # [ACTION-IF-NOT-FOUND])
3370 #
3371 #
3372 # Note that if there is a possibility the first call to
3373 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3374 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3375 #
3376 #
3377 # --------------------------------------------------------------
3378 # PKG_CHECK_MODULES
3379
3380
3381 # Include these first...
3382 #
3383 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3384 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3385 #
3386 # This code is free software; you can redistribute it and/or modify it
3387 # under the terms of the GNU General Public License version 2 only, as
3388 # published by the Free Software Foundation. Oracle designates this
3389 # particular file as subject to the "Classpath" exception as provided
3390 # by Oracle in the LICENSE file that accompanied this code.
3391 #
3392 # This code is distributed in the hope that it will be useful, but WITHOUT
3393 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3394 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3395 # version 2 for more details (a copy is included in the LICENSE file that
3396 # accompanied this code).
3397 #
3398 # You should have received a copy of the GNU General Public License version
3399 # 2 along with this work; if not, write to the Free Software Foundation,
3400 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3401 #
3402 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3403 # or visit www.oracle.com if you need additional information or have any
3404 # questions.
3405 #
3406
3407 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3408 # If so, then append $1 to $2 \
3409 # Also set JVM_ARG_OK to true/false depending on outcome.
3410
3411
3412 # Appends a string to a path variable, only adding the : when needed.
3413
3414
3415 # Prepends a string to a path variable, only adding the : when needed.
3416
3417
3418 # This will make sure the given variable points to a full and proper
3419 # path. This means:
3420 # 1) There will be no spaces in the path. On unix platforms,
3421 # spaces in the path will result in an error. On Windows,
3422 # the path will be rewritten using short-style to be space-free.
3423 # 2) The path will be absolute, and it will be in unix-style (on
3424 # cygwin).
3425 # $1: The name of the variable to fix
3426
3427
3428 # This will make sure the given variable points to a executable
3429 # with a full and proper path. This means:
3430 # 1) There will be no spaces in the path. On unix platforms,
3431 # spaces in the path will result in an error. On Windows,
3432 # the path will be rewritten using short-style to be space-free.
3433 # 2) The path will be absolute, and it will be in unix-style (on
3434 # cygwin).
3435 # Any arguments given to the executable is preserved.
3436 # If the input variable does not have a directory specification, then
3437 # it need to be in the PATH.
3438 # $1: The name of the variable to fix
3439
3440
3441
3442
3443 # Register a --with argument but mark it as deprecated
3444 # $1: The name of the with argument to deprecate, not including --with-
3445
3446
3447 # Register a --enable argument but mark it as deprecated
3448 # $1: The name of the with argument to deprecate, not including --enable-
3449 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3450
3451
3452
3453
3454 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3455 # $1: variable to check
3456
3457
3458 # Check that there are no unprocessed overridden variables left.
3459 # If so, they are an incorrect argument and we will exit with an error.
3460
3461
3462 # Setup a tool for the given variable. If correctly specified by the user,
3463 # use that value, otherwise search for the tool using the supplied code snippet.
3464 # $1: variable to set
3465 # $2: code snippet to call to look for the tool
3466
3467
3468 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3469 # $1: variable to set
3470 # $2: executable name (or list of names) to look for
3471
3472
3473 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3474 # $1: variable to set
3475 # $2: executable name (or list of names) to look for
3476
3477
3478 # Like BASIC_PATH_PROGS but fails if no tool was found.
3479 # $1: variable to set
3480 # $2: executable name (or list of names) to look for
3481
3482
3483 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3484 # $1: variable to set
3485 # $2: autoconf macro to call to look for the special tool
3486
3487
3488 # Setup the most fundamental tools that relies on not much else to set up,
3489 # but is used by much of the early bootstrap code.
3490
3491
3492 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3493
3494
3495 # Evaluates platform specific overrides for devkit variables.
3496 # $1: Name of variable
3497
3498
3499
3500
3501
3502
3503 #%%% Simple tools %%%
3504
3505 # Check if we have found a usable version of make
3506 # $1: the path to a potential make binary (or empty)
3507 # $2: the description on how we found this
3508
3509
3510
3511
3512 # Goes looking for a usable version of GNU make.
3513
3514
3515
3516
3517
3518
3519 # Check if build directory is on local disk. If not possible to determine,
3520 # we prefer to claim it's local.
3521 # Argument 1: directory to test
3522 # Argument 2: what to do if it is on local disk
3523 # Argument 3: what to do otherwise (remote disk or failure)
3524
3525
3526 # Check that source files have basic read permissions set. This might
3527 # not be the case in cygwin in certain conditions.
3528
3529
3530
3531
3532 # Check for support for specific options in bash
3533
3534
3535 # Code to run after AC_OUTPUT
3536
3537
3538 #
3539 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3540 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3541 #
3542 # This code is free software; you can redistribute it and/or modify it
3543 # under the terms of the GNU General Public License version 2 only, as
3544 # published by the Free Software Foundation. Oracle designates this
3545 # particular file as subject to the "Classpath" exception as provided
3546 # by Oracle in the LICENSE file that accompanied this code.
3547 #
3548 # This code is distributed in the hope that it will be useful, but WITHOUT
3549 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3550 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3551 # version 2 for more details (a copy is included in the LICENSE file that
3552 # accompanied this code).
3553 #
3554 # You should have received a copy of the GNU General Public License version
3555 # 2 along with this work; if not, write to the Free Software Foundation,
3556 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3557 #
3558 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3559 # or visit www.oracle.com if you need additional information or have any
3560 # questions.
3561 #
3562
3563
3564
3565
3566
3567 # Helper function which possibly converts a path using DOS-style short mode.
3568 # If so, the updated path is stored in $new_path.
3569 # $1: The path to check
3570
3571
3572 # Helper function which possibly converts a path using DOS-style short mode.
3573 # If so, the updated path is stored in $new_path.
3574 # $1: The path to check
3575
3576
3577 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3578 # and could probably be heavily simplified. However, all changes in this
3579 # area tend to need lot of testing in different scenarios, and in lack of
3580 # proper unit testing, cleaning this up has not been deemed worth the effort
3581 # at the moment.
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3592
3593
3594
3595
3596 #
3597 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3598 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3599 #
3600 # This code is free software; you can redistribute it and/or modify it
3601 # under the terms of the GNU General Public License version 2 only, as
3602 # published by the Free Software Foundation. Oracle designates this
3603 # particular file as subject to the "Classpath" exception as provided
3604 # by Oracle in the LICENSE file that accompanied this code.
3605 #
3606 # This code is distributed in the hope that it will be useful, but WITHOUT
3607 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3608 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3609 # version 2 for more details (a copy is included in the LICENSE file that
3610 # accompanied this code).
3611 #
3612 # You should have received a copy of the GNU General Public License version
3613 # 2 along with this work; if not, write to the Free Software Foundation,
3614 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3615 #
3616 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3617 # or visit www.oracle.com if you need additional information or have any
3618 # questions.
3619 #
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631 # ... then the rest
3632 #
3633 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3634 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3635 #
3636 # This code is free software; you can redistribute it and/or modify it
3637 # under the terms of the GNU General Public License version 2 only, as
3638 # published by the Free Software Foundation. Oracle designates this
3639 # particular file as subject to the "Classpath" exception as provided
3640 # by Oracle in the LICENSE file that accompanied this code.
3641 #
3642 # This code is distributed in the hope that it will be useful, but WITHOUT
3643 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3644 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3645 # version 2 for more details (a copy is included in the LICENSE file that
3646 # accompanied this code).
3647 #
3648 # You should have received a copy of the GNU General Public License version
3649 # 2 along with this work; if not, write to the Free Software Foundation,
3650 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3651 #
3652 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3653 # or visit www.oracle.com if you need additional information or have any
3654 # questions.
3655 #
3656
3657 ########################################################################
3658 # This file handles detection of the Boot JDK. The Boot JDK detection
3659 # process has been developed as a response to solve a complex real-world
3660 # problem. Initially, it was simple, but it has grown as platform after
3661 # platform, idiosyncracy after idiosyncracy has been supported.
3662 #
3663 # The basic idea is this:
3664 # 1) You need an acceptable *) JDK to use as a Boot JDK
3665 # 2) There are several ways to locate a JDK, that are mostly platform
3666 # dependent **)
3667 # 3) You can have multiple JDKs installed
3668 # 4) If possible, configure should try to dig out an acceptable JDK
3669 # automatically, without having to resort to command-line options
3670 #
3671 # *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3672 # javac) and not a JRE, etc.
3673 #
3674 # **) On Windows we typically use a well-known path.
3675 # On MacOSX we typically use the tool java_home.
3676 # On Linux we typically find javac in the $PATH, and then follow a
3677 # chain of symlinks that often ends up in a real JDK.
3678 #
3679 # This leads to the code where we check in different ways to locate a
3680 # JDK, and if one is found, check if it is acceptable. If not, we print
3681 # our reasons for rejecting it (useful when debugging non-working
3682 # configure situations) and continue checking the next one.
3683 ########################################################################
3684
3685 # Execute the check given as argument, and verify the result
3686 # If the Boot JDK was previously found, do nothing
3687 # $1 A command line (typically autoconf macro) to execute
3688
3689
3690 # Test: Is bootjdk explicitely set by command line arguments?
3691
3692
3693 # Test: Is bootjdk available from builddeps?
3694
3695
3696 # Test: Is $JAVA_HOME set?
3697
3698
3699 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3700
3701
3702 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3703 # $1: Argument to the java_home binary (optional)
3704
3705
3706 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3707
3708
3709 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3710 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3711 # $1 = Path to directory containing jdk installations.
3712 # $2 = String to append to the found JDK directory to get the proper JDK home
3713
3714
3715 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3716 # environmental variable as base for where to look.
3717 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3718
3719
3720 # Test: Is there a JDK installed in default, well-known locations?
3721
3722
3723 # Check that a command-line tool in the Boot JDK is correct
3724 # $1 = name of variable to assign
3725 # $2 = name of binary
3726
3727
3728 ###############################################################################
3729 #
3730 # We need a Boot JDK to bootstrap the build.
3731 #
3732
3733
3734
3735
3736
3737 #
3738 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3739 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3740 #
3741 # This code is free software; you can redistribute it and/or modify it
3742 # under the terms of the GNU General Public License version 2 only, as
3743 # published by the Free Software Foundation. Oracle designates this
3744 # particular file as subject to the "Classpath" exception as provided
3745 # by Oracle in the LICENSE file that accompanied this code.
3746 #
3747 # This code is distributed in the hope that it will be useful, but WITHOUT
3748 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3749 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3750 # version 2 for more details (a copy is included in the LICENSE file that
3751 # accompanied this code).
3752 #
3753 # You should have received a copy of the GNU General Public License version
3754 # 2 along with this work; if not, write to the Free Software Foundation,
3755 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3756 #
3757 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3758 # or visit www.oracle.com if you need additional information or have any
3759 # questions.
3760 #
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781 #
3782 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3783 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3784 #
3785 # This code is free software; you can redistribute it and/or modify it
3786 # under the terms of the GNU General Public License version 2 only, as
3787 # published by the Free Software Foundation. Oracle designates this
3788 # particular file as subject to the "Classpath" exception as provided
3789 # by Oracle in the LICENSE file that accompanied this code.
3790 #
3791 # This code is distributed in the hope that it will be useful, but WITHOUT
3792 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3793 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3794 # version 2 for more details (a copy is included in the LICENSE file that
3795 # accompanied this code).
3796 #
3797 # You should have received a copy of the GNU General Public License version
3798 # 2 along with this work; if not, write to the Free Software Foundation,
3799 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3800 #
3801 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3802 # or visit www.oracle.com if you need additional information or have any
3803 # questions.
3804 #
3805
3806
3807
3808
3809
3810 # Documentation on common flags used for solstudio in HIGHEST.
3811 #
3812 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3813 # done with care, there are some assumptions below that need to
3814 # be understood about the use of pointers, and IEEE behavior.
3815 #
3816 # -fns: Use non-standard floating point mode (not IEEE 754)
3817 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3818 # -fsingle: Use single precision floating point with 'float'
3819 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3820 # (Source with excessing pointer casting and data access with mixed
3821 # pointer types are not recommended)
3822 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3823 # (If you expect perfect errno behavior, do not use this)
3824 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3825 # -xrestrict: Pointer parameters to functions do not overlap
3826 # (Similar to -xalias_level=basic usage, but less obvious sometimes.
3827 # If you pass in multiple pointers to the same data, do not use this)
3828 # -xlibmil: Inline some library routines
3829 # (If you expect perfect errno behavior, do not use this)
3830 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3831 # (If you expect perfect errno behavior, do not use this)
3832 # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3833
3834 # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3835 # Bug?
3836 #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3837 # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3838 # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3839 #fi
3840
3841
3842
3843
3844
3845 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3846 # [RUN-IF-FALSE])
3847 # ------------------------------------------------------------
3848 # Check that the c and c++ compilers support an argument
3849
3850
3851 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3852 # [RUN-IF-FALSE])
3853 # ------------------------------------------------------------
3854 # Check that the linker support an argument
3855
3856
3857
3858
3859 #
3860 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3861 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3862 #
3863 # This code is free software; you can redistribute it and/or modify it
3864 # under the terms of the GNU General Public License version 2 only, as
3865 # published by the Free Software Foundation. Oracle designates this
3866 # particular file as subject to the "Classpath" exception as provided
3867 # by Oracle in the LICENSE file that accompanied this code.
3868 #
3869 # This code is distributed in the hope that it will be useful, but WITHOUT
3870 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3871 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3872 # version 2 for more details (a copy is included in the LICENSE file that
3873 # accompanied this code).
3874 #
3875 # You should have received a copy of the GNU General Public License version
3876 # 2 along with this work; if not, write to the Free Software Foundation,
3877 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3878 #
3879 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3880 # or visit www.oracle.com if you need additional information or have any
3881 # questions.
3882 #
3883
3884
3885
3886
3887
3888 cygwin_help() {
3889 case $1 in
3890 unzip)
3891 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3892 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3893 ;;
3894 zip)
3895 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3896 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3897 ;;
3898 make)
3899 PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3900 HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3901 ;;
3902 freetype)
3903 HELP_MSG="
3904 The freetype library can now be build during the configure process.
3905 Download the freetype sources and unpack them into an arbitrary directory:
3906
3907 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3908 tar -xzf freetype-2.5.3.tar.gz
3909
3910 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3911 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3912 builds or into '<freetype_src>/lib32' for 32-bit builds.
3913 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3914 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3915 ;;
3916 esac
3917 }
3918
3919 msys_help() {
3920 PKGHANDLER_COMMAND=""
3921 }
3922
3923 apt_help() {
3924 case $1 in
3925 devkit)
3926 PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3927 openjdk)
3928 PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3929 alsa)
3930 PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3931 cups)
3932 PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3933 freetype)
3934 PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3935 pulse)
3936 PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3937 x11)
3938 PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3939 ccache)
3940 PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3941 esac
3942 }
3943
3944 yum_help() {
3945 case $1 in
3946 devkit)
3947 PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3948 openjdk)
3949 PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3950 alsa)
3951 PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3952 cups)
3953 PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3954 freetype)
3955 PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3956 pulse)
3957 PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3958 x11)
3959 PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3960 ccache)
3961 PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3962 esac
3963 }
3964
3965 port_help() {
3966 PKGHANDLER_COMMAND=""
3967 }
3968
3969 pkgutil_help() {
3970 PKGHANDLER_COMMAND=""
3971 }
3972
3973 pkgadd_help() {
3974 PKGHANDLER_COMMAND=""
3975 }
3976
3977 # This function will check if we're called from the "configure" wrapper while
3978 # printing --help. If so, we will print out additional information that can
3979 # only be extracted within the autoconf script, and then exit. This must be
3980 # called at the very beginning in configure.ac.
3981
3982
3983
3984
3985
3986
3987 #
3988 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3989 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3990 #
3991 # This code is free software; you can redistribute it and/or modify it
3992 # under the terms of the GNU General Public License version 2 only, as
3993 # published by the Free Software Foundation. Oracle designates this
3994 # particular file as subject to the "Classpath" exception as provided
3995 # by Oracle in the LICENSE file that accompanied this code.
3996 #
3997 # This code is distributed in the hope that it will be useful, but WITHOUT
3998 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3999 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4000 # version 2 for more details (a copy is included in the LICENSE file that
4001 # accompanied this code).
4002 #
4003 # You should have received a copy of the GNU General Public License version
4004 # 2 along with this work; if not, write to the Free Software Foundation,
4005 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4006 #
4007 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4008 # or visit www.oracle.com if you need additional information or have any
4009 # questions.
4010 #
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021 ###############################################################################
4022 #
4023 # Should we build only OpenJDK even if closed sources are present?
4024 #
4025
4026
4027
4028
4029
4030
4031 ###############################################################################
4032 #
4033 # Enable or disable the elliptic curve crypto implementation
4034 #
4035
4036
4037
4038
4039
4040 ################################################################################
4041 #
4042 # Gcov coverage data for hotspot
4043 #
4044
4045
4046 #
4047 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4048 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4049 #
4050 # This code is free software; you can redistribute it and/or modify it
4051 # under the terms of the GNU General Public License version 2 only, as
4052 # published by the Free Software Foundation. Oracle designates this
4053 # particular file as subject to the "Classpath" exception as provided
4054 # by Oracle in the LICENSE file that accompanied this code.
4055 #
4056 # This code is distributed in the hope that it will be useful, but WITHOUT
4057 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4058 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4059 # version 2 for more details (a copy is included in the LICENSE file that
4060 # accompanied this code).
4061 #
4062 # You should have received a copy of the GNU General Public License version
4063 # 2 along with this work; if not, write to the Free Software Foundation,
4064 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4065 #
4066 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4067 # or visit www.oracle.com if you need additional information or have any
4068 # questions.
4069 #
4070
4071 ###############################################################################
4072 #
4073 # Setup version numbers
4074 #
4075
4076 # Verify that a given string represents a valid version number, and assign it
4077 # to a variable.
4078
4079 # Argument 1: the variable to assign to
4080 # Argument 2: the value given by the user
4081
4082
4083
4084
4085 #
4086 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
4087 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4088 #
4089 # This code is free software; you can redistribute it and/or modify it
4090 # under the terms of the GNU General Public License version 2 only, as
4091 # published by the Free Software Foundation. Oracle designates this
4092 # particular file as subject to the "Classpath" exception as provided
4093 # by Oracle in the LICENSE file that accompanied this code.
4094 #
4095 # This code is distributed in the hope that it will be useful, but WITHOUT
4096 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4097 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4098 # version 2 for more details (a copy is included in the LICENSE file that
4099 # accompanied this code).
4100 #
4101 # You should have received a copy of the GNU General Public License version
4102 # 2 along with this work; if not, write to the Free Software Foundation,
4103 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4104 #
4105 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4106 # or visit www.oracle.com if you need additional information or have any
4107 # questions.
4108 #
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130 #
4131 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4132 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4133 #
4134 # This code is free software; you can redistribute it and/or modify it
4135 # under the terms of the GNU General Public License version 2 only, as
4136 # published by the Free Software Foundation. Oracle designates this
4137 # particular file as subject to the "Classpath" exception as provided
4138 # by Oracle in the LICENSE file that accompanied this code.
4139 #
4140 # This code is distributed in the hope that it will be useful, but WITHOUT
4141 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4142 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4143 # version 2 for more details (a copy is included in the LICENSE file that
4144 # accompanied this code).
4145 #
4146 # You should have received a copy of the GNU General Public License version
4147 # 2 along with this work; if not, write to the Free Software Foundation,
4148 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4149 #
4150 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4151 # or visit www.oracle.com if you need additional information or have any
4152 # questions.
4153 #
4154
4155 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4156 # Converts autoconf style CPU name to OpenJDK style, into
4157 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4158
4159
4160 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4161 # Converts autoconf style OS name to OpenJDK style, into
4162 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4163
4164
4165 # Expects $host_os $host_cpu $build_os and $build_cpu
4166 # and $with_target_bits to have been setup!
4167 #
4168 # Translate the standard triplet(quadruplet) definition
4169 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4170 # OPENJDK_BUILD_OS, etc.
4171
4172
4173 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4174 # accordingly. Must be done after setting up build and target system, but before
4175 # doing anything else with these values.
4176
4177
4178 # Setup the legacy variables, for controlling the old makefiles.
4179 #
4180
4181
4182
4183
4184 #%%% Build and target systems %%%
4185
4186
4187
4188
4189 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4190 # Add -mX to various FLAGS variables.
4191
4192
4193
4194
4195
4196
4197 #
4198 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4199 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4200 #
4201 # This code is free software; you can redistribute it and/or modify it
4202 # under the terms of the GNU General Public License version 2 only, as
4203 # published by the Free Software Foundation. Oracle designates this
4204 # particular file as subject to the "Classpath" exception as provided
4205 # by Oracle in the LICENSE file that accompanied this code.
4206 #
4207 # This code is distributed in the hope that it will be useful, but WITHOUT
4208 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4209 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4210 # version 2 for more details (a copy is included in the LICENSE file that
4211 # accompanied this code).
4212 #
4213 # You should have received a copy of the GNU General Public License version
4214 # 2 along with this work; if not, write to the Free Software Foundation,
4215 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4216 #
4217 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4218 # or visit www.oracle.com if you need additional information or have any
4219 # questions.
4220 #
4221
4222
4223
4224
4225
4226
4227
4228
4229 #
4230 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4231 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4232 #
4233 # This code is free software; you can redistribute it and/or modify it
4234 # under the terms of the GNU General Public License version 2 only, as
4235 # published by the Free Software Foundation. Oracle designates this
4236 # particular file as subject to the "Classpath" exception as provided
4237 # by Oracle in the LICENSE file that accompanied this code.
4238 #
4239 # This code is distributed in the hope that it will be useful, but WITHOUT
4240 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4241 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4242 # version 2 for more details (a copy is included in the LICENSE file that
4243 # accompanied this code).
4244 #
4245 # You should have received a copy of the GNU General Public License version
4246 # 2 along with this work; if not, write to the Free Software Foundation,
4247 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4248 #
4249 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4250 # or visit www.oracle.com if you need additional information or have any
4251 # questions.
4252 #
4253
4254 ########################################################################
4255 # This file is responsible for detecting, verifying and setting up the
4256 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4257 # proper paths to the binaries, but it will not setup any flags.
4258 #
4259 # The binaries used is determined by the toolchain type, which is the family of
4260 # compilers and related tools that are used.
4261 ########################################################################
4262
4263
4264 # All valid toolchains, regardless of platform (used by help.m4)
4265 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4266
4267 # These toolchains are valid on different platforms
4268 VALID_TOOLCHAINS_linux="gcc clang"
4269 VALID_TOOLCHAINS_solaris="solstudio"
4270 VALID_TOOLCHAINS_macosx="gcc clang"
4271 VALID_TOOLCHAINS_aix="xlc"
4272 VALID_TOOLCHAINS_windows="microsoft"
4273
4274 # Toolchain descriptions
4275 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4276 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4277 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4278 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4279 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4280
4281 # Setup a number of variables describing how native output files are
4282 # named on this platform/toolchain.
4283
4284
4285 # Determine which toolchain type to use, and make sure it is valid for this
4286 # platform. Setup various information about the selected toolchain.
4287
4288
4289 # Before we start detecting the toolchain executables, we might need some
4290 # special setup, e.g. additional paths etc.
4291
4292
4293 # Restore path, etc
4294
4295
4296 # Check if a compiler is of the toolchain type we expect, and save the version
4297 # information from it. If the compiler does not match the expected type,
4298 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4299 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4300 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4301 #
4302 # $1 = compiler to test (CC or CXX)
4303 # $2 = human readable name of compiler (C or C++)
4304
4305
4306 # Try to locate the given C or C++ compiler in the path, or otherwise.
4307 #
4308 # $1 = compiler to test (CC or CXX)
4309 # $2 = human readable name of compiler (C or C++)
4310 # $3 = list of compiler names to search for
4311
4312
4313 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4314 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4315 # archiver (AR). Verify that the compilers are correct according to the
4316 # toolchain type.
4317
4318
4319 # Setup additional tools that is considered a part of the toolchain, but not the
4320 # core part. Many of these are highly platform-specific and do not exist,
4321 # and/or are not needed on all platforms.
4322
4323
4324 # Setup the build tools (i.e, the compiler and linker used to build programs
4325 # that should be run on the build platform, not the target platform, as a build
4326 # helper). Since the non-cross-compile case uses the normal, target compilers
4327 # for this, we can only do this after these have been setup.
4328
4329
4330 # Setup legacy variables that are still needed as alternative ways to refer to
4331 # parts of the toolchain.
4332
4333
4334 # Do some additional checks on the detected tools.
4335
4336
4337 # Setup the JTReg Regression Test Harness.
4338
4339
4340 #
4341 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4342 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4343 #
4344 # This code is free software; you can redistribute it and/or modify it
4345 # under the terms of the GNU General Public License version 2 only, as
4346 # published by the Free Software Foundation. Oracle designates this
4347 # particular file as subject to the "Classpath" exception as provided
4348 # by Oracle in the LICENSE file that accompanied this code.
4349 #
4350 # This code is distributed in the hope that it will be useful, but WITHOUT
4351 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4352 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4353 # version 2 for more details (a copy is included in the LICENSE file that
4354 # accompanied this code).
4355 #
4356 # You should have received a copy of the GNU General Public License version
4357 # 2 along with this work; if not, write to the Free Software Foundation,
4358 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4359 #
4360 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4361 # or visit www.oracle.com if you need additional information or have any
4362 # questions.
4363 #
4364
4365 ################################################################################
4366 # The order of these defines the priority by which we try to find them.
4367 VALID_VS_VERSIONS="2013 2012 2010"
4368
4369 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4370 VS_VERSION_INTERNAL_2010=100
4371 VS_MSVCR_2010=msvcr100.dll
4372 # We don't use msvcp on Visual Studio 2010
4373 #VS_MSVCP_2010=msvcp100.dll
4374 VS_ENVVAR_2010="VS100COMNTOOLS"
4375 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4376 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4377 VS_VS_PLATFORM_NAME_2010="v100"
4378 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4379
4380 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4381 VS_VERSION_INTERNAL_2012=110
4382 VS_MSVCR_2012=msvcr110.dll
4383 VS_MSVCP_2012=msvcp110.dll
4384 VS_ENVVAR_2012="VS110COMNTOOLS"
4385 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4386 VS_SDK_INSTALLDIR_2012=
4387 VS_VS_PLATFORM_NAME_2012="v110"
4388 VS_SDK_PLATFORM_NAME_2012=
4389
4390 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4391 VS_VERSION_INTERNAL_2013=120
4392 VS_MSVCR_2013=msvcr120.dll
4393 VS_MSVCP_2013=msvcp120.dll
4394 VS_ENVVAR_2013="VS120COMNTOOLS"
4395 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4396 VS_SDK_INSTALLDIR_2013=
4397 VS_VS_PLATFORM_NAME_2013="v120"
4398 VS_SDK_PLATFORM_NAME_2013=
4399
4400 ################################################################################
4401
4402
4403
4404 ################################################################################
4405
4406
4407
4408 ################################################################################
4409 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4410 # build environment and assigns it to VS_ENV_CMD
4411
4412
4413 ################################################################################
4414
4415
4416
4417 ################################################################################
4418 # Check if the VS env variables were setup prior to running configure.
4419 # If not, then find vcvarsall.bat and run it automatically, and integrate
4420 # the set env variables into the spec file.
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435 # This line needs to be here, verbatim, after all includes and the dummy hook
4436 # definitions. It is replaced with custom functionality when building
4437 # custom sources.
4438 #CUSTOM_AUTOCONF_INCLUDE
4439
4440 # Do not change or remove the following line, it is needed for consistency checks:
4441 DATE_WHEN_GENERATED=1433857590
4442
4443 ###############################################################################
4444 #
4445 # Initialization / Boot-strapping
4446 #
4447 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4448 # thus it jumps back and forth, each time gaining something needed later on.
4449 #
4450 ###############################################################################
4451
4452 # If we are requested to print additional help, do that and then exit.
4453 # This must be the very first call.
4454
4455 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4456 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4457 $PRINTF "Which are valid to use depends on the build platform.\n"
4458 for toolchain in $VALID_TOOLCHAINS_all; do
4459 # Use indirect variable referencing
4460 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4461 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4462 $PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4463 done
4464
4465 # And now exit directly
4466 exit 0
4467 fi
4468
4469
4470 # Basic initialization that must happen first of all in the normal process.
4471
4472 # Save the original command line. This is passed to us by the wrapper configure script.
4473
4474 # Save the path variable before it gets changed
4475 ORIGINAL_PATH="$PATH"
4476
4477 DATE_WHEN_CONFIGURED=`LANG=C date`
4478
4479 { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4480 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4481 { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4482 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4483
4484
4485 # Start with tools that do not need have cross compilation support
4486 # and can be expected to be found in the default PATH. These tools are
4487 # used by configure. Nor are these tools expected to be found in the
4488 # devkit from the builddeps server either, since they are
4489 # needed to download the devkit.
4490
4491 # First are all the simple required tools.
4492
4493
4494
4495 # Publish this variable in the help.
4496
4497
4498 if test "x$BASENAME" = x; then
4499 # The variable is not set by user, try to locate tool using the code snippet
4500 for ac_prog in basename
4501 do
4502 # Extract the first word of "$ac_prog", so it can be a program name with args.
4503 set dummy $ac_prog; ac_word=$2
4504 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4505 $as_echo_n "checking for $ac_word... " >&6; }
4506 if ${ac_cv_path_BASENAME+:} false; then :
4507 $as_echo_n "(cached) " >&6
4508 else
4509 case $BASENAME in
4510 [\\/]* | ?:[\\/]*)
4511 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4512 ;;
4513 *)
4514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4515 for as_dir in $PATH
4516 do
4517 IFS=$as_save_IFS
4518 test -z "$as_dir" && as_dir=.
4519 for ac_exec_ext in '' $ac_executable_extensions; do
4520 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4521 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4522 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4523 break 2
4524 fi
4525 done
4526 done
4527 IFS=$as_save_IFS
4528
4529 ;;
4530 esac
4531 fi
4532 BASENAME=$ac_cv_path_BASENAME
4533 if test -n "$BASENAME"; then
4534 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4535 $as_echo "$BASENAME" >&6; }
4536 else
4537 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4538 $as_echo "no" >&6; }
4539 fi
4540
4541
4542 test -n "$BASENAME" && break
4543 done
4544
4545 else
4546 # The variable is set, but is it from the command line or the environment?
4547
4548 # Try to remove the string !BASENAME! from our list.
4549 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4550 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4551 # If it failed, the variable was not from the command line. Ignore it,
4552 # but warn the user (except for BASH, which is always set by the calling BASH).
4553 if test "xBASENAME" != xBASH; then
4554 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4555 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4556 fi
4557 # Try to locate tool using the code snippet
4558 for ac_prog in basename
4559 do
4560 # Extract the first word of "$ac_prog", so it can be a program name with args.
4561 set dummy $ac_prog; ac_word=$2
4562 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4563 $as_echo_n "checking for $ac_word... " >&6; }
4564 if ${ac_cv_path_BASENAME+:} false; then :
4565 $as_echo_n "(cached) " >&6
4566 else
4567 case $BASENAME in
4568 [\\/]* | ?:[\\/]*)
4569 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4570 ;;
4571 *)
4572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4573 for as_dir in $PATH
4574 do
4575 IFS=$as_save_IFS
4576 test -z "$as_dir" && as_dir=.
4577 for ac_exec_ext in '' $ac_executable_extensions; do
4578 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4579 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4580 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4581 break 2
4582 fi
4583 done
4584 done
4585 IFS=$as_save_IFS
4586
4587 ;;
4588 esac
4589 fi
4590 BASENAME=$ac_cv_path_BASENAME
4591 if test -n "$BASENAME"; then
4592 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4593 $as_echo "$BASENAME" >&6; }
4594 else
4595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4596 $as_echo "no" >&6; }
4597 fi
4598
4599
4600 test -n "$BASENAME" && break
4601 done
4602
4603 else
4604 # If it succeeded, then it was overridden by the user. We will use it
4605 # for the tool.
4606
4607 # First remove it from the list of overridden variables, so we can test
4608 # for unknown variables in the end.
4609 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4610
4611 # Check if the provided tool contains a complete path.
4612 tool_specified="$BASENAME"
4613 tool_basename="${tool_specified##*/}"
4614 if test "x$tool_basename" = "x$tool_specified"; then
4615 # A command without a complete path is provided, search $PATH.
4616 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4617 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4618 # Extract the first word of "$tool_basename", so it can be a program name with args.
4619 set dummy $tool_basename; ac_word=$2
4620 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4621 $as_echo_n "checking for $ac_word... " >&6; }
4622 if ${ac_cv_path_BASENAME+:} false; then :
4623 $as_echo_n "(cached) " >&6
4624 else
4625 case $BASENAME in
4626 [\\/]* | ?:[\\/]*)
4627 ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4628 ;;
4629 *)
4630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4631 for as_dir in $PATH
4632 do
4633 IFS=$as_save_IFS
4634 test -z "$as_dir" && as_dir=.
4635 for ac_exec_ext in '' $ac_executable_extensions; do
4636 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4637 ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4638 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4639 break 2
4640 fi
4641 done
4642 done
4643 IFS=$as_save_IFS
4644
4645 ;;
4646 esac
4647 fi
4648 BASENAME=$ac_cv_path_BASENAME
4649 if test -n "$BASENAME"; then
4650 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4651 $as_echo "$BASENAME" >&6; }
4652 else
4653 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4654 $as_echo "no" >&6; }
4655 fi
4656
4657
4658 if test "x$BASENAME" = x; then
4659 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4660 fi
4661 else
4662 # Otherwise we believe it is a complete path. Use it as it is.
4663 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4664 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4666 $as_echo_n "checking for BASENAME... " >&6; }
4667 if test ! -x "$tool_specified"; then
4668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4669 $as_echo "not found" >&6; }
4670 as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4671 fi
4672 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4673 $as_echo "$tool_specified" >&6; }
4674 fi
4675 fi
4676 fi
4677
4678
4679
4680 if test "x$BASENAME" = x; then
4681 as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4682 fi
4683
4684
4685
4686
4687
4688 # Publish this variable in the help.
4689
4690
4691 if test "x$BASH" = x; then
4692 # The variable is not set by user, try to locate tool using the code snippet
4693 for ac_prog in bash
4694 do
4695 # Extract the first word of "$ac_prog", so it can be a program name with args.
4696 set dummy $ac_prog; ac_word=$2
4697 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4698 $as_echo_n "checking for $ac_word... " >&6; }
4699 if ${ac_cv_path_BASH+:} false; then :
4700 $as_echo_n "(cached) " >&6
4701 else
4702 case $BASH in
4703 [\\/]* | ?:[\\/]*)
4704 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4705 ;;
4706 *)
4707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4708 for as_dir in $PATH
4709 do
4710 IFS=$as_save_IFS
4711 test -z "$as_dir" && as_dir=.
4712 for ac_exec_ext in '' $ac_executable_extensions; do
4713 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4714 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4715 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4716 break 2
4717 fi
4718 done
4719 done
4720 IFS=$as_save_IFS
4721
4722 ;;
4723 esac
4724 fi
4725 BASH=$ac_cv_path_BASH
4726 if test -n "$BASH"; then
4727 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4728 $as_echo "$BASH" >&6; }
4729 else
4730 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4731 $as_echo "no" >&6; }
4732 fi
4733
4734
4735 test -n "$BASH" && break
4736 done
4737
4738 else
4739 # The variable is set, but is it from the command line or the environment?
4740
4741 # Try to remove the string !BASH! from our list.
4742 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4743 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4744 # If it failed, the variable was not from the command line. Ignore it,
4745 # but warn the user (except for BASH, which is always set by the calling BASH).
4746 if test "xBASH" != xBASH; then
4747 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4748 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4749 fi
4750 # Try to locate tool using the code snippet
4751 for ac_prog in bash
4752 do
4753 # Extract the first word of "$ac_prog", so it can be a program name with args.
4754 set dummy $ac_prog; ac_word=$2
4755 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4756 $as_echo_n "checking for $ac_word... " >&6; }
4757 if ${ac_cv_path_BASH+:} false; then :
4758 $as_echo_n "(cached) " >&6
4759 else
4760 case $BASH in
4761 [\\/]* | ?:[\\/]*)
4762 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4763 ;;
4764 *)
4765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4766 for as_dir in $PATH
4767 do
4768 IFS=$as_save_IFS
4769 test -z "$as_dir" && as_dir=.
4770 for ac_exec_ext in '' $ac_executable_extensions; do
4771 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4772 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4773 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4774 break 2
4775 fi
4776 done
4777 done
4778 IFS=$as_save_IFS
4779
4780 ;;
4781 esac
4782 fi
4783 BASH=$ac_cv_path_BASH
4784 if test -n "$BASH"; then
4785 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4786 $as_echo "$BASH" >&6; }
4787 else
4788 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4789 $as_echo "no" >&6; }
4790 fi
4791
4792
4793 test -n "$BASH" && break
4794 done
4795
4796 else
4797 # If it succeeded, then it was overridden by the user. We will use it
4798 # for the tool.
4799
4800 # First remove it from the list of overridden variables, so we can test
4801 # for unknown variables in the end.
4802 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4803
4804 # Check if the provided tool contains a complete path.
4805 tool_specified="$BASH"
4806 tool_basename="${tool_specified##*/}"
4807 if test "x$tool_basename" = "x$tool_specified"; then
4808 # A command without a complete path is provided, search $PATH.
4809 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4810 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4811 # Extract the first word of "$tool_basename", so it can be a program name with args.
4812 set dummy $tool_basename; ac_word=$2
4813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4814 $as_echo_n "checking for $ac_word... " >&6; }
4815 if ${ac_cv_path_BASH+:} false; then :
4816 $as_echo_n "(cached) " >&6
4817 else
4818 case $BASH in
4819 [\\/]* | ?:[\\/]*)
4820 ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4821 ;;
4822 *)
4823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4824 for as_dir in $PATH
4825 do
4826 IFS=$as_save_IFS
4827 test -z "$as_dir" && as_dir=.
4828 for ac_exec_ext in '' $ac_executable_extensions; do
4829 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4830 ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4831 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4832 break 2
4833 fi
4834 done
4835 done
4836 IFS=$as_save_IFS
4837
4838 ;;
4839 esac
4840 fi
4841 BASH=$ac_cv_path_BASH
4842 if test -n "$BASH"; then
4843 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4844 $as_echo "$BASH" >&6; }
4845 else
4846 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4847 $as_echo "no" >&6; }
4848 fi
4849
4850
4851 if test "x$BASH" = x; then
4852 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4853 fi
4854 else
4855 # Otherwise we believe it is a complete path. Use it as it is.
4856 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4857 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4859 $as_echo_n "checking for BASH... " >&6; }
4860 if test ! -x "$tool_specified"; then
4861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4862 $as_echo "not found" >&6; }
4863 as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4864 fi
4865 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4866 $as_echo "$tool_specified" >&6; }
4867 fi
4868 fi
4869 fi
4870
4871
4872
4873 if test "x$BASH" = x; then
4874 as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4875 fi
4876
4877
4878
4879
4880
4881 # Publish this variable in the help.
4882
4883
4884 if test "x$CAT" = x; then
4885 # The variable is not set by user, try to locate tool using the code snippet
4886 for ac_prog in cat
4887 do
4888 # Extract the first word of "$ac_prog", so it can be a program name with args.
4889 set dummy $ac_prog; ac_word=$2
4890 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4891 $as_echo_n "checking for $ac_word... " >&6; }
4892 if ${ac_cv_path_CAT+:} false; then :
4893 $as_echo_n "(cached) " >&6
4894 else
4895 case $CAT in
4896 [\\/]* | ?:[\\/]*)
4897 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4898 ;;
4899 *)
4900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4901 for as_dir in $PATH
4902 do
4903 IFS=$as_save_IFS
4904 test -z "$as_dir" && as_dir=.
4905 for ac_exec_ext in '' $ac_executable_extensions; do
4906 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4907 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4908 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4909 break 2
4910 fi
4911 done
4912 done
4913 IFS=$as_save_IFS
4914
4915 ;;
4916 esac
4917 fi
4918 CAT=$ac_cv_path_CAT
4919 if test -n "$CAT"; then
4920 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4921 $as_echo "$CAT" >&6; }
4922 else
4923 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4924 $as_echo "no" >&6; }
4925 fi
4926
4927
4928 test -n "$CAT" && break
4929 done
4930
4931 else
4932 # The variable is set, but is it from the command line or the environment?
4933
4934 # Try to remove the string !CAT! from our list.
4935 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4936 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4937 # If it failed, the variable was not from the command line. Ignore it,
4938 # but warn the user (except for BASH, which is always set by the calling BASH).
4939 if test "xCAT" != xBASH; then
4940 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4941 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4942 fi
4943 # Try to locate tool using the code snippet
4944 for ac_prog in cat
4945 do
4946 # Extract the first word of "$ac_prog", so it can be a program name with args.
4947 set dummy $ac_prog; ac_word=$2
4948 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4949 $as_echo_n "checking for $ac_word... " >&6; }
4950 if ${ac_cv_path_CAT+:} false; then :
4951 $as_echo_n "(cached) " >&6
4952 else
4953 case $CAT in
4954 [\\/]* | ?:[\\/]*)
4955 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4956 ;;
4957 *)
4958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4959 for as_dir in $PATH
4960 do
4961 IFS=$as_save_IFS
4962 test -z "$as_dir" && as_dir=.
4963 for ac_exec_ext in '' $ac_executable_extensions; do
4964 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4965 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4966 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4967 break 2
4968 fi
4969 done
4970 done
4971 IFS=$as_save_IFS
4972
4973 ;;
4974 esac
4975 fi
4976 CAT=$ac_cv_path_CAT
4977 if test -n "$CAT"; then
4978 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4979 $as_echo "$CAT" >&6; }
4980 else
4981 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4982 $as_echo "no" >&6; }
4983 fi
4984
4985
4986 test -n "$CAT" && break
4987 done
4988
4989 else
4990 # If it succeeded, then it was overridden by the user. We will use it
4991 # for the tool.
4992
4993 # First remove it from the list of overridden variables, so we can test
4994 # for unknown variables in the end.
4995 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4996
4997 # Check if the provided tool contains a complete path.
4998 tool_specified="$CAT"
4999 tool_basename="${tool_specified##*/}"
5000 if test "x$tool_basename" = "x$tool_specified"; then
5001 # A command without a complete path is provided, search $PATH.
5002 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5003 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5004 # Extract the first word of "$tool_basename", so it can be a program name with args.
5005 set dummy $tool_basename; ac_word=$2
5006 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5007 $as_echo_n "checking for $ac_word... " >&6; }
5008 if ${ac_cv_path_CAT+:} false; then :
5009 $as_echo_n "(cached) " >&6
5010 else
5011 case $CAT in
5012 [\\/]* | ?:[\\/]*)
5013 ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5014 ;;
5015 *)
5016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5017 for as_dir in $PATH
5018 do
5019 IFS=$as_save_IFS
5020 test -z "$as_dir" && as_dir=.
5021 for ac_exec_ext in '' $ac_executable_extensions; do
5022 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5023 ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5024 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5025 break 2
5026 fi
5027 done
5028 done
5029 IFS=$as_save_IFS
5030
5031 ;;
5032 esac
5033 fi
5034 CAT=$ac_cv_path_CAT
5035 if test -n "$CAT"; then
5036 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5037 $as_echo "$CAT" >&6; }
5038 else
5039 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5040 $as_echo "no" >&6; }
5041 fi
5042
5043
5044 if test "x$CAT" = x; then
5045 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5046 fi
5047 else
5048 # Otherwise we believe it is a complete path. Use it as it is.
5049 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5050 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5052 $as_echo_n "checking for CAT... " >&6; }
5053 if test ! -x "$tool_specified"; then
5054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5055 $as_echo "not found" >&6; }
5056 as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5057 fi
5058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5059 $as_echo "$tool_specified" >&6; }
5060 fi
5061 fi
5062 fi
5063
5064
5065
5066 if test "x$CAT" = x; then
5067 as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5068 fi
5069
5070
5071
5072
5073
5074 # Publish this variable in the help.
5075
5076
5077 if test "x$CHMOD" = x; then
5078 # The variable is not set by user, try to locate tool using the code snippet
5079 for ac_prog in chmod
5080 do
5081 # Extract the first word of "$ac_prog", so it can be a program name with args.
5082 set dummy $ac_prog; ac_word=$2
5083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5084 $as_echo_n "checking for $ac_word... " >&6; }
5085 if ${ac_cv_path_CHMOD+:} false; then :
5086 $as_echo_n "(cached) " >&6
5087 else
5088 case $CHMOD in
5089 [\\/]* | ?:[\\/]*)
5090 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5091 ;;
5092 *)
5093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5094 for as_dir in $PATH
5095 do
5096 IFS=$as_save_IFS
5097 test -z "$as_dir" && as_dir=.
5098 for ac_exec_ext in '' $ac_executable_extensions; do
5099 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5100 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5101 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5102 break 2
5103 fi
5104 done
5105 done
5106 IFS=$as_save_IFS
5107
5108 ;;
5109 esac
5110 fi
5111 CHMOD=$ac_cv_path_CHMOD
5112 if test -n "$CHMOD"; then
5113 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5114 $as_echo "$CHMOD" >&6; }
5115 else
5116 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5117 $as_echo "no" >&6; }
5118 fi
5119
5120
5121 test -n "$CHMOD" && break
5122 done
5123
5124 else
5125 # The variable is set, but is it from the command line or the environment?
5126
5127 # Try to remove the string !CHMOD! from our list.
5128 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5129 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5130 # If it failed, the variable was not from the command line. Ignore it,
5131 # but warn the user (except for BASH, which is always set by the calling BASH).
5132 if test "xCHMOD" != xBASH; then
5133 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5134 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5135 fi
5136 # Try to locate tool using the code snippet
5137 for ac_prog in chmod
5138 do
5139 # Extract the first word of "$ac_prog", so it can be a program name with args.
5140 set dummy $ac_prog; ac_word=$2
5141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5142 $as_echo_n "checking for $ac_word... " >&6; }
5143 if ${ac_cv_path_CHMOD+:} false; then :
5144 $as_echo_n "(cached) " >&6
5145 else
5146 case $CHMOD in
5147 [\\/]* | ?:[\\/]*)
5148 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5149 ;;
5150 *)
5151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5152 for as_dir in $PATH
5153 do
5154 IFS=$as_save_IFS
5155 test -z "$as_dir" && as_dir=.
5156 for ac_exec_ext in '' $ac_executable_extensions; do
5157 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5158 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5159 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5160 break 2
5161 fi
5162 done
5163 done
5164 IFS=$as_save_IFS
5165
5166 ;;
5167 esac
5168 fi
5169 CHMOD=$ac_cv_path_CHMOD
5170 if test -n "$CHMOD"; then
5171 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5172 $as_echo "$CHMOD" >&6; }
5173 else
5174 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5175 $as_echo "no" >&6; }
5176 fi
5177
5178
5179 test -n "$CHMOD" && break
5180 done
5181
5182 else
5183 # If it succeeded, then it was overridden by the user. We will use it
5184 # for the tool.
5185
5186 # First remove it from the list of overridden variables, so we can test
5187 # for unknown variables in the end.
5188 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5189
5190 # Check if the provided tool contains a complete path.
5191 tool_specified="$CHMOD"
5192 tool_basename="${tool_specified##*/}"
5193 if test "x$tool_basename" = "x$tool_specified"; then
5194 # A command without a complete path is provided, search $PATH.
5195 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5196 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5197 # Extract the first word of "$tool_basename", so it can be a program name with args.
5198 set dummy $tool_basename; ac_word=$2
5199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5200 $as_echo_n "checking for $ac_word... " >&6; }
5201 if ${ac_cv_path_CHMOD+:} false; then :
5202 $as_echo_n "(cached) " >&6
5203 else
5204 case $CHMOD in
5205 [\\/]* | ?:[\\/]*)
5206 ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5207 ;;
5208 *)
5209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5210 for as_dir in $PATH
5211 do
5212 IFS=$as_save_IFS
5213 test -z "$as_dir" && as_dir=.
5214 for ac_exec_ext in '' $ac_executable_extensions; do
5215 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5216 ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5217 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5218 break 2
5219 fi
5220 done
5221 done
5222 IFS=$as_save_IFS
5223
5224 ;;
5225 esac
5226 fi
5227 CHMOD=$ac_cv_path_CHMOD
5228 if test -n "$CHMOD"; then
5229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5230 $as_echo "$CHMOD" >&6; }
5231 else
5232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5233 $as_echo "no" >&6; }
5234 fi
5235
5236
5237 if test "x$CHMOD" = x; then
5238 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5239 fi
5240 else
5241 # Otherwise we believe it is a complete path. Use it as it is.
5242 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5243 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5245 $as_echo_n "checking for CHMOD... " >&6; }
5246 if test ! -x "$tool_specified"; then
5247 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5248 $as_echo "not found" >&6; }
5249 as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5250 fi
5251 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5252 $as_echo "$tool_specified" >&6; }
5253 fi
5254 fi
5255 fi
5256
5257
5258
5259 if test "x$CHMOD" = x; then
5260 as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5261 fi
5262
5263
5264
5265
5266
5267 # Publish this variable in the help.
5268
5269
5270 if test "x$CMP" = x; then
5271 # The variable is not set by user, try to locate tool using the code snippet
5272 for ac_prog in cmp
5273 do
5274 # Extract the first word of "$ac_prog", so it can be a program name with args.
5275 set dummy $ac_prog; ac_word=$2
5276 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5277 $as_echo_n "checking for $ac_word... " >&6; }
5278 if ${ac_cv_path_CMP+:} false; then :
5279 $as_echo_n "(cached) " >&6
5280 else
5281 case $CMP in
5282 [\\/]* | ?:[\\/]*)
5283 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5284 ;;
5285 *)
5286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5287 for as_dir in $PATH
5288 do
5289 IFS=$as_save_IFS
5290 test -z "$as_dir" && as_dir=.
5291 for ac_exec_ext in '' $ac_executable_extensions; do
5292 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5293 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5294 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5295 break 2
5296 fi
5297 done
5298 done
5299 IFS=$as_save_IFS
5300
5301 ;;
5302 esac
5303 fi
5304 CMP=$ac_cv_path_CMP
5305 if test -n "$CMP"; then
5306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5307 $as_echo "$CMP" >&6; }
5308 else
5309 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5310 $as_echo "no" >&6; }
5311 fi
5312
5313
5314 test -n "$CMP" && break
5315 done
5316
5317 else
5318 # The variable is set, but is it from the command line or the environment?
5319
5320 # Try to remove the string !CMP! from our list.
5321 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5322 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5323 # If it failed, the variable was not from the command line. Ignore it,
5324 # but warn the user (except for BASH, which is always set by the calling BASH).
5325 if test "xCMP" != xBASH; then
5326 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5327 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5328 fi
5329 # Try to locate tool using the code snippet
5330 for ac_prog in cmp
5331 do
5332 # Extract the first word of "$ac_prog", so it can be a program name with args.
5333 set dummy $ac_prog; ac_word=$2
5334 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5335 $as_echo_n "checking for $ac_word... " >&6; }
5336 if ${ac_cv_path_CMP+:} false; then :
5337 $as_echo_n "(cached) " >&6
5338 else
5339 case $CMP in
5340 [\\/]* | ?:[\\/]*)
5341 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5342 ;;
5343 *)
5344 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5345 for as_dir in $PATH
5346 do
5347 IFS=$as_save_IFS
5348 test -z "$as_dir" && as_dir=.
5349 for ac_exec_ext in '' $ac_executable_extensions; do
5350 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5351 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5352 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5353 break 2
5354 fi
5355 done
5356 done
5357 IFS=$as_save_IFS
5358
5359 ;;
5360 esac
5361 fi
5362 CMP=$ac_cv_path_CMP
5363 if test -n "$CMP"; then
5364 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5365 $as_echo "$CMP" >&6; }
5366 else
5367 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5368 $as_echo "no" >&6; }
5369 fi
5370
5371
5372 test -n "$CMP" && break
5373 done
5374
5375 else
5376 # If it succeeded, then it was overridden by the user. We will use it
5377 # for the tool.
5378
5379 # First remove it from the list of overridden variables, so we can test
5380 # for unknown variables in the end.
5381 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5382
5383 # Check if the provided tool contains a complete path.
5384 tool_specified="$CMP"
5385 tool_basename="${tool_specified##*/}"
5386 if test "x$tool_basename" = "x$tool_specified"; then
5387 # A command without a complete path is provided, search $PATH.
5388 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5389 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5390 # Extract the first word of "$tool_basename", so it can be a program name with args.
5391 set dummy $tool_basename; ac_word=$2
5392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5393 $as_echo_n "checking for $ac_word... " >&6; }
5394 if ${ac_cv_path_CMP+:} false; then :
5395 $as_echo_n "(cached) " >&6
5396 else
5397 case $CMP in
5398 [\\/]* | ?:[\\/]*)
5399 ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5400 ;;
5401 *)
5402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5403 for as_dir in $PATH
5404 do
5405 IFS=$as_save_IFS
5406 test -z "$as_dir" && as_dir=.
5407 for ac_exec_ext in '' $ac_executable_extensions; do
5408 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5409 ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5410 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5411 break 2
5412 fi
5413 done
5414 done
5415 IFS=$as_save_IFS
5416
5417 ;;
5418 esac
5419 fi
5420 CMP=$ac_cv_path_CMP
5421 if test -n "$CMP"; then
5422 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5423 $as_echo "$CMP" >&6; }
5424 else
5425 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5426 $as_echo "no" >&6; }
5427 fi
5428
5429
5430 if test "x$CMP" = x; then
5431 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5432 fi
5433 else
5434 # Otherwise we believe it is a complete path. Use it as it is.
5435 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5436 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5437 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5438 $as_echo_n "checking for CMP... " >&6; }
5439 if test ! -x "$tool_specified"; then
5440 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5441 $as_echo "not found" >&6; }
5442 as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5443 fi
5444 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5445 $as_echo "$tool_specified" >&6; }
5446 fi
5447 fi
5448 fi
5449
5450
5451
5452 if test "x$CMP" = x; then
5453 as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5454 fi
5455
5456
5457
5458
5459
5460 # Publish this variable in the help.
5461
5462
5463 if test "x$COMM" = x; then
5464 # The variable is not set by user, try to locate tool using the code snippet
5465 for ac_prog in comm
5466 do
5467 # Extract the first word of "$ac_prog", so it can be a program name with args.
5468 set dummy $ac_prog; ac_word=$2
5469 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5470 $as_echo_n "checking for $ac_word... " >&6; }
5471 if ${ac_cv_path_COMM+:} false; then :
5472 $as_echo_n "(cached) " >&6
5473 else
5474 case $COMM in
5475 [\\/]* | ?:[\\/]*)
5476 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5477 ;;
5478 *)
5479 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5480 for as_dir in $PATH
5481 do
5482 IFS=$as_save_IFS
5483 test -z "$as_dir" && as_dir=.
5484 for ac_exec_ext in '' $ac_executable_extensions; do
5485 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5486 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5487 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5488 break 2
5489 fi
5490 done
5491 done
5492 IFS=$as_save_IFS
5493
5494 ;;
5495 esac
5496 fi
5497 COMM=$ac_cv_path_COMM
5498 if test -n "$COMM"; then
5499 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5500 $as_echo "$COMM" >&6; }
5501 else
5502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5503 $as_echo "no" >&6; }
5504 fi
5505
5506
5507 test -n "$COMM" && break
5508 done
5509
5510 else
5511 # The variable is set, but is it from the command line or the environment?
5512
5513 # Try to remove the string !COMM! from our list.
5514 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5515 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5516 # If it failed, the variable was not from the command line. Ignore it,
5517 # but warn the user (except for BASH, which is always set by the calling BASH).
5518 if test "xCOMM" != xBASH; then
5519 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5520 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5521 fi
5522 # Try to locate tool using the code snippet
5523 for ac_prog in comm
5524 do
5525 # Extract the first word of "$ac_prog", so it can be a program name with args.
5526 set dummy $ac_prog; ac_word=$2
5527 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5528 $as_echo_n "checking for $ac_word... " >&6; }
5529 if ${ac_cv_path_COMM+:} false; then :
5530 $as_echo_n "(cached) " >&6
5531 else
5532 case $COMM in
5533 [\\/]* | ?:[\\/]*)
5534 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5535 ;;
5536 *)
5537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5538 for as_dir in $PATH
5539 do
5540 IFS=$as_save_IFS
5541 test -z "$as_dir" && as_dir=.
5542 for ac_exec_ext in '' $ac_executable_extensions; do
5543 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5544 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5545 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5546 break 2
5547 fi
5548 done
5549 done
5550 IFS=$as_save_IFS
5551
5552 ;;
5553 esac
5554 fi
5555 COMM=$ac_cv_path_COMM
5556 if test -n "$COMM"; then
5557 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5558 $as_echo "$COMM" >&6; }
5559 else
5560 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5561 $as_echo "no" >&6; }
5562 fi
5563
5564
5565 test -n "$COMM" && break
5566 done
5567
5568 else
5569 # If it succeeded, then it was overridden by the user. We will use it
5570 # for the tool.
5571
5572 # First remove it from the list of overridden variables, so we can test
5573 # for unknown variables in the end.
5574 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5575
5576 # Check if the provided tool contains a complete path.
5577 tool_specified="$COMM"
5578 tool_basename="${tool_specified##*/}"
5579 if test "x$tool_basename" = "x$tool_specified"; then
5580 # A command without a complete path is provided, search $PATH.
5581 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5582 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5583 # Extract the first word of "$tool_basename", so it can be a program name with args.
5584 set dummy $tool_basename; ac_word=$2
5585 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5586 $as_echo_n "checking for $ac_word... " >&6; }
5587 if ${ac_cv_path_COMM+:} false; then :
5588 $as_echo_n "(cached) " >&6
5589 else
5590 case $COMM in
5591 [\\/]* | ?:[\\/]*)
5592 ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5593 ;;
5594 *)
5595 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5596 for as_dir in $PATH
5597 do
5598 IFS=$as_save_IFS
5599 test -z "$as_dir" && as_dir=.
5600 for ac_exec_ext in '' $ac_executable_extensions; do
5601 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5602 ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5603 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5604 break 2
5605 fi
5606 done
5607 done
5608 IFS=$as_save_IFS
5609
5610 ;;
5611 esac
5612 fi
5613 COMM=$ac_cv_path_COMM
5614 if test -n "$COMM"; then
5615 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5616 $as_echo "$COMM" >&6; }
5617 else
5618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5619 $as_echo "no" >&6; }
5620 fi
5621
5622
5623 if test "x$COMM" = x; then
5624 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5625 fi
5626 else
5627 # Otherwise we believe it is a complete path. Use it as it is.
5628 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5629 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5631 $as_echo_n "checking for COMM... " >&6; }
5632 if test ! -x "$tool_specified"; then
5633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5634 $as_echo "not found" >&6; }
5635 as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5636 fi
5637 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5638 $as_echo "$tool_specified" >&6; }
5639 fi
5640 fi
5641 fi
5642
5643
5644
5645 if test "x$COMM" = x; then
5646 as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5647 fi
5648
5649
5650
5651
5652
5653 # Publish this variable in the help.
5654
5655
5656 if test "x$CP" = x; then
5657 # The variable is not set by user, try to locate tool using the code snippet
5658 for ac_prog in cp
5659 do
5660 # Extract the first word of "$ac_prog", so it can be a program name with args.
5661 set dummy $ac_prog; ac_word=$2
5662 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5663 $as_echo_n "checking for $ac_word... " >&6; }
5664 if ${ac_cv_path_CP+:} false; then :
5665 $as_echo_n "(cached) " >&6
5666 else
5667 case $CP in
5668 [\\/]* | ?:[\\/]*)
5669 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5670 ;;
5671 *)
5672 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5673 for as_dir in $PATH
5674 do
5675 IFS=$as_save_IFS
5676 test -z "$as_dir" && as_dir=.
5677 for ac_exec_ext in '' $ac_executable_extensions; do
5678 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5679 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5680 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5681 break 2
5682 fi
5683 done
5684 done
5685 IFS=$as_save_IFS
5686
5687 ;;
5688 esac
5689 fi
5690 CP=$ac_cv_path_CP
5691 if test -n "$CP"; then
5692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5693 $as_echo "$CP" >&6; }
5694 else
5695 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5696 $as_echo "no" >&6; }
5697 fi
5698
5699
5700 test -n "$CP" && break
5701 done
5702
5703 else
5704 # The variable is set, but is it from the command line or the environment?
5705
5706 # Try to remove the string !CP! from our list.
5707 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5708 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5709 # If it failed, the variable was not from the command line. Ignore it,
5710 # but warn the user (except for BASH, which is always set by the calling BASH).
5711 if test "xCP" != xBASH; then
5712 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5713 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5714 fi
5715 # Try to locate tool using the code snippet
5716 for ac_prog in cp
5717 do
5718 # Extract the first word of "$ac_prog", so it can be a program name with args.
5719 set dummy $ac_prog; ac_word=$2
5720 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5721 $as_echo_n "checking for $ac_word... " >&6; }
5722 if ${ac_cv_path_CP+:} false; then :
5723 $as_echo_n "(cached) " >&6
5724 else
5725 case $CP in
5726 [\\/]* | ?:[\\/]*)
5727 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5728 ;;
5729 *)
5730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5731 for as_dir in $PATH
5732 do
5733 IFS=$as_save_IFS
5734 test -z "$as_dir" && as_dir=.
5735 for ac_exec_ext in '' $ac_executable_extensions; do
5736 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5737 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5738 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5739 break 2
5740 fi
5741 done
5742 done
5743 IFS=$as_save_IFS
5744
5745 ;;
5746 esac
5747 fi
5748 CP=$ac_cv_path_CP
5749 if test -n "$CP"; then
5750 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5751 $as_echo "$CP" >&6; }
5752 else
5753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5754 $as_echo "no" >&6; }
5755 fi
5756
5757
5758 test -n "$CP" && break
5759 done
5760
5761 else
5762 # If it succeeded, then it was overridden by the user. We will use it
5763 # for the tool.
5764
5765 # First remove it from the list of overridden variables, so we can test
5766 # for unknown variables in the end.
5767 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5768
5769 # Check if the provided tool contains a complete path.
5770 tool_specified="$CP"
5771 tool_basename="${tool_specified##*/}"
5772 if test "x$tool_basename" = "x$tool_specified"; then
5773 # A command without a complete path is provided, search $PATH.
5774 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5775 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5776 # Extract the first word of "$tool_basename", so it can be a program name with args.
5777 set dummy $tool_basename; ac_word=$2
5778 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5779 $as_echo_n "checking for $ac_word... " >&6; }
5780 if ${ac_cv_path_CP+:} false; then :
5781 $as_echo_n "(cached) " >&6
5782 else
5783 case $CP in
5784 [\\/]* | ?:[\\/]*)
5785 ac_cv_path_CP="$CP" # Let the user override the test with a path.
5786 ;;
5787 *)
5788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5789 for as_dir in $PATH
5790 do
5791 IFS=$as_save_IFS
5792 test -z "$as_dir" && as_dir=.
5793 for ac_exec_ext in '' $ac_executable_extensions; do
5794 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5795 ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5796 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5797 break 2
5798 fi
5799 done
5800 done
5801 IFS=$as_save_IFS
5802
5803 ;;
5804 esac
5805 fi
5806 CP=$ac_cv_path_CP
5807 if test -n "$CP"; then
5808 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5809 $as_echo "$CP" >&6; }
5810 else
5811 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5812 $as_echo "no" >&6; }
5813 fi
5814
5815
5816 if test "x$CP" = x; then
5817 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5818 fi
5819 else
5820 # Otherwise we believe it is a complete path. Use it as it is.
5821 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5822 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5824 $as_echo_n "checking for CP... " >&6; }
5825 if test ! -x "$tool_specified"; then
5826 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5827 $as_echo "not found" >&6; }
5828 as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5829 fi
5830 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5831 $as_echo "$tool_specified" >&6; }
5832 fi
5833 fi
5834 fi
5835
5836
5837
5838 if test "x$CP" = x; then
5839 as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5840 fi
5841
5842
5843
5844
5845
5846 # Publish this variable in the help.
5847
5848
5849 if test "x$CUT" = x; then
5850 # The variable is not set by user, try to locate tool using the code snippet
5851 for ac_prog in cut
5852 do
5853 # Extract the first word of "$ac_prog", so it can be a program name with args.
5854 set dummy $ac_prog; ac_word=$2
5855 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5856 $as_echo_n "checking for $ac_word... " >&6; }
5857 if ${ac_cv_path_CUT+:} false; then :
5858 $as_echo_n "(cached) " >&6
5859 else
5860 case $CUT in
5861 [\\/]* | ?:[\\/]*)
5862 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5863 ;;
5864 *)
5865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5866 for as_dir in $PATH
5867 do
5868 IFS=$as_save_IFS
5869 test -z "$as_dir" && as_dir=.
5870 for ac_exec_ext in '' $ac_executable_extensions; do
5871 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5872 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5873 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5874 break 2
5875 fi
5876 done
5877 done
5878 IFS=$as_save_IFS
5879
5880 ;;
5881 esac
5882 fi
5883 CUT=$ac_cv_path_CUT
5884 if test -n "$CUT"; then
5885 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5886 $as_echo "$CUT" >&6; }
5887 else
5888 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5889 $as_echo "no" >&6; }
5890 fi
5891
5892
5893 test -n "$CUT" && break
5894 done
5895
5896 else
5897 # The variable is set, but is it from the command line or the environment?
5898
5899 # Try to remove the string !CUT! from our list.
5900 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5901 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5902 # If it failed, the variable was not from the command line. Ignore it,
5903 # but warn the user (except for BASH, which is always set by the calling BASH).
5904 if test "xCUT" != xBASH; then
5905 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5906 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5907 fi
5908 # Try to locate tool using the code snippet
5909 for ac_prog in cut
5910 do
5911 # Extract the first word of "$ac_prog", so it can be a program name with args.
5912 set dummy $ac_prog; ac_word=$2
5913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5914 $as_echo_n "checking for $ac_word... " >&6; }
5915 if ${ac_cv_path_CUT+:} false; then :
5916 $as_echo_n "(cached) " >&6
5917 else
5918 case $CUT in
5919 [\\/]* | ?:[\\/]*)
5920 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5921 ;;
5922 *)
5923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5924 for as_dir in $PATH
5925 do
5926 IFS=$as_save_IFS
5927 test -z "$as_dir" && as_dir=.
5928 for ac_exec_ext in '' $ac_executable_extensions; do
5929 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5930 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5931 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5932 break 2
5933 fi
5934 done
5935 done
5936 IFS=$as_save_IFS
5937
5938 ;;
5939 esac
5940 fi
5941 CUT=$ac_cv_path_CUT
5942 if test -n "$CUT"; then
5943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5944 $as_echo "$CUT" >&6; }
5945 else
5946 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5947 $as_echo "no" >&6; }
5948 fi
5949
5950
5951 test -n "$CUT" && break
5952 done
5953
5954 else
5955 # If it succeeded, then it was overridden by the user. We will use it
5956 # for the tool.
5957
5958 # First remove it from the list of overridden variables, so we can test
5959 # for unknown variables in the end.
5960 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5961
5962 # Check if the provided tool contains a complete path.
5963 tool_specified="$CUT"
5964 tool_basename="${tool_specified##*/}"
5965 if test "x$tool_basename" = "x$tool_specified"; then
5966 # A command without a complete path is provided, search $PATH.
5967 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5968 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5969 # Extract the first word of "$tool_basename", so it can be a program name with args.
5970 set dummy $tool_basename; ac_word=$2
5971 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5972 $as_echo_n "checking for $ac_word... " >&6; }
5973 if ${ac_cv_path_CUT+:} false; then :
5974 $as_echo_n "(cached) " >&6
5975 else
5976 case $CUT in
5977 [\\/]* | ?:[\\/]*)
5978 ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5979 ;;
5980 *)
5981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5982 for as_dir in $PATH
5983 do
5984 IFS=$as_save_IFS
5985 test -z "$as_dir" && as_dir=.
5986 for ac_exec_ext in '' $ac_executable_extensions; do
5987 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5988 ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5989 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5990 break 2
5991 fi
5992 done
5993 done
5994 IFS=$as_save_IFS
5995
5996 ;;
5997 esac
5998 fi
5999 CUT=$ac_cv_path_CUT
6000 if test -n "$CUT"; then
6001 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6002 $as_echo "$CUT" >&6; }
6003 else
6004 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6005 $as_echo "no" >&6; }
6006 fi
6007
6008
6009 if test "x$CUT" = x; then
6010 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6011 fi
6012 else
6013 # Otherwise we believe it is a complete path. Use it as it is.
6014 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6015 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6016 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6017 $as_echo_n "checking for CUT... " >&6; }
6018 if test ! -x "$tool_specified"; then
6019 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6020 $as_echo "not found" >&6; }
6021 as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6022 fi
6023 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6024 $as_echo "$tool_specified" >&6; }
6025 fi
6026 fi
6027 fi
6028
6029
6030
6031 if test "x$CUT" = x; then
6032 as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6033 fi
6034
6035
6036
6037
6038
6039 # Publish this variable in the help.
6040
6041
6042 if test "x$DATE" = x; then
6043 # The variable is not set by user, try to locate tool using the code snippet
6044 for ac_prog in date
6045 do
6046 # Extract the first word of "$ac_prog", so it can be a program name with args.
6047 set dummy $ac_prog; ac_word=$2
6048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6049 $as_echo_n "checking for $ac_word... " >&6; }
6050 if ${ac_cv_path_DATE+:} false; then :
6051 $as_echo_n "(cached) " >&6
6052 else
6053 case $DATE in
6054 [\\/]* | ?:[\\/]*)
6055 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6056 ;;
6057 *)
6058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6059 for as_dir in $PATH
6060 do
6061 IFS=$as_save_IFS
6062 test -z "$as_dir" && as_dir=.
6063 for ac_exec_ext in '' $ac_executable_extensions; do
6064 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6065 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6066 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6067 break 2
6068 fi
6069 done
6070 done
6071 IFS=$as_save_IFS
6072
6073 ;;
6074 esac
6075 fi
6076 DATE=$ac_cv_path_DATE
6077 if test -n "$DATE"; then
6078 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6079 $as_echo "$DATE" >&6; }
6080 else
6081 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6082 $as_echo "no" >&6; }
6083 fi
6084
6085
6086 test -n "$DATE" && break
6087 done
6088
6089 else
6090 # The variable is set, but is it from the command line or the environment?
6091
6092 # Try to remove the string !DATE! from our list.
6093 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6094 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6095 # If it failed, the variable was not from the command line. Ignore it,
6096 # but warn the user (except for BASH, which is always set by the calling BASH).
6097 if test "xDATE" != xBASH; then
6098 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6099 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6100 fi
6101 # Try to locate tool using the code snippet
6102 for ac_prog in date
6103 do
6104 # Extract the first word of "$ac_prog", so it can be a program name with args.
6105 set dummy $ac_prog; ac_word=$2
6106 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6107 $as_echo_n "checking for $ac_word... " >&6; }
6108 if ${ac_cv_path_DATE+:} false; then :
6109 $as_echo_n "(cached) " >&6
6110 else
6111 case $DATE in
6112 [\\/]* | ?:[\\/]*)
6113 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6114 ;;
6115 *)
6116 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6117 for as_dir in $PATH
6118 do
6119 IFS=$as_save_IFS
6120 test -z "$as_dir" && as_dir=.
6121 for ac_exec_ext in '' $ac_executable_extensions; do
6122 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6123 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6124 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6125 break 2
6126 fi
6127 done
6128 done
6129 IFS=$as_save_IFS
6130
6131 ;;
6132 esac
6133 fi
6134 DATE=$ac_cv_path_DATE
6135 if test -n "$DATE"; then
6136 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6137 $as_echo "$DATE" >&6; }
6138 else
6139 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6140 $as_echo "no" >&6; }
6141 fi
6142
6143
6144 test -n "$DATE" && break
6145 done
6146
6147 else
6148 # If it succeeded, then it was overridden by the user. We will use it
6149 # for the tool.
6150
6151 # First remove it from the list of overridden variables, so we can test
6152 # for unknown variables in the end.
6153 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6154
6155 # Check if the provided tool contains a complete path.
6156 tool_specified="$DATE"
6157 tool_basename="${tool_specified##*/}"
6158 if test "x$tool_basename" = "x$tool_specified"; then
6159 # A command without a complete path is provided, search $PATH.
6160 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6161 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6162 # Extract the first word of "$tool_basename", so it can be a program name with args.
6163 set dummy $tool_basename; ac_word=$2
6164 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6165 $as_echo_n "checking for $ac_word... " >&6; }
6166 if ${ac_cv_path_DATE+:} false; then :
6167 $as_echo_n "(cached) " >&6
6168 else
6169 case $DATE in
6170 [\\/]* | ?:[\\/]*)
6171 ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6172 ;;
6173 *)
6174 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6175 for as_dir in $PATH
6176 do
6177 IFS=$as_save_IFS
6178 test -z "$as_dir" && as_dir=.
6179 for ac_exec_ext in '' $ac_executable_extensions; do
6180 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6181 ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6182 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6183 break 2
6184 fi
6185 done
6186 done
6187 IFS=$as_save_IFS
6188
6189 ;;
6190 esac
6191 fi
6192 DATE=$ac_cv_path_DATE
6193 if test -n "$DATE"; then
6194 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6195 $as_echo "$DATE" >&6; }
6196 else
6197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6198 $as_echo "no" >&6; }
6199 fi
6200
6201
6202 if test "x$DATE" = x; then
6203 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6204 fi
6205 else
6206 # Otherwise we believe it is a complete path. Use it as it is.
6207 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6208 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6210 $as_echo_n "checking for DATE... " >&6; }
6211 if test ! -x "$tool_specified"; then
6212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6213 $as_echo "not found" >&6; }
6214 as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6215 fi
6216 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6217 $as_echo "$tool_specified" >&6; }
6218 fi
6219 fi
6220 fi
6221
6222
6223
6224 if test "x$DATE" = x; then
6225 as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6226 fi
6227
6228
6229
6230
6231
6232 # Publish this variable in the help.
6233
6234
6235 if test "x$DIFF" = x; then
6236 # The variable is not set by user, try to locate tool using the code snippet
6237 for ac_prog in gdiff diff
6238 do
6239 # Extract the first word of "$ac_prog", so it can be a program name with args.
6240 set dummy $ac_prog; ac_word=$2
6241 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6242 $as_echo_n "checking for $ac_word... " >&6; }
6243 if ${ac_cv_path_DIFF+:} false; then :
6244 $as_echo_n "(cached) " >&6
6245 else
6246 case $DIFF in
6247 [\\/]* | ?:[\\/]*)
6248 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6249 ;;
6250 *)
6251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6252 for as_dir in $PATH
6253 do
6254 IFS=$as_save_IFS
6255 test -z "$as_dir" && as_dir=.
6256 for ac_exec_ext in '' $ac_executable_extensions; do
6257 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6258 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6259 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6260 break 2
6261 fi
6262 done
6263 done
6264 IFS=$as_save_IFS
6265
6266 ;;
6267 esac
6268 fi
6269 DIFF=$ac_cv_path_DIFF
6270 if test -n "$DIFF"; then
6271 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6272 $as_echo "$DIFF" >&6; }
6273 else
6274 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6275 $as_echo "no" >&6; }
6276 fi
6277
6278
6279 test -n "$DIFF" && break
6280 done
6281
6282 else
6283 # The variable is set, but is it from the command line or the environment?
6284
6285 # Try to remove the string !DIFF! from our list.
6286 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6287 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6288 # If it failed, the variable was not from the command line. Ignore it,
6289 # but warn the user (except for BASH, which is always set by the calling BASH).
6290 if test "xDIFF" != xBASH; then
6291 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6292 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6293 fi
6294 # Try to locate tool using the code snippet
6295 for ac_prog in gdiff diff
6296 do
6297 # Extract the first word of "$ac_prog", so it can be a program name with args.
6298 set dummy $ac_prog; ac_word=$2
6299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6300 $as_echo_n "checking for $ac_word... " >&6; }
6301 if ${ac_cv_path_DIFF+:} false; then :
6302 $as_echo_n "(cached) " >&6
6303 else
6304 case $DIFF in
6305 [\\/]* | ?:[\\/]*)
6306 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6307 ;;
6308 *)
6309 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6310 for as_dir in $PATH
6311 do
6312 IFS=$as_save_IFS
6313 test -z "$as_dir" && as_dir=.
6314 for ac_exec_ext in '' $ac_executable_extensions; do
6315 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6316 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6317 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6318 break 2
6319 fi
6320 done
6321 done
6322 IFS=$as_save_IFS
6323
6324 ;;
6325 esac
6326 fi
6327 DIFF=$ac_cv_path_DIFF
6328 if test -n "$DIFF"; then
6329 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6330 $as_echo "$DIFF" >&6; }
6331 else
6332 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6333 $as_echo "no" >&6; }
6334 fi
6335
6336
6337 test -n "$DIFF" && break
6338 done
6339
6340 else
6341 # If it succeeded, then it was overridden by the user. We will use it
6342 # for the tool.
6343
6344 # First remove it from the list of overridden variables, so we can test
6345 # for unknown variables in the end.
6346 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6347
6348 # Check if the provided tool contains a complete path.
6349 tool_specified="$DIFF"
6350 tool_basename="${tool_specified##*/}"
6351 if test "x$tool_basename" = "x$tool_specified"; then
6352 # A command without a complete path is provided, search $PATH.
6353 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6354 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6355 # Extract the first word of "$tool_basename", so it can be a program name with args.
6356 set dummy $tool_basename; ac_word=$2
6357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6358 $as_echo_n "checking for $ac_word... " >&6; }
6359 if ${ac_cv_path_DIFF+:} false; then :
6360 $as_echo_n "(cached) " >&6
6361 else
6362 case $DIFF in
6363 [\\/]* | ?:[\\/]*)
6364 ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6365 ;;
6366 *)
6367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6368 for as_dir in $PATH
6369 do
6370 IFS=$as_save_IFS
6371 test -z "$as_dir" && as_dir=.
6372 for ac_exec_ext in '' $ac_executable_extensions; do
6373 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6374 ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6375 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6376 break 2
6377 fi
6378 done
6379 done
6380 IFS=$as_save_IFS
6381
6382 ;;
6383 esac
6384 fi
6385 DIFF=$ac_cv_path_DIFF
6386 if test -n "$DIFF"; then
6387 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6388 $as_echo "$DIFF" >&6; }
6389 else
6390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6391 $as_echo "no" >&6; }
6392 fi
6393
6394
6395 if test "x$DIFF" = x; then
6396 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6397 fi
6398 else
6399 # Otherwise we believe it is a complete path. Use it as it is.
6400 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6401 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6402 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6403 $as_echo_n "checking for DIFF... " >&6; }
6404 if test ! -x "$tool_specified"; then
6405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6406 $as_echo "not found" >&6; }
6407 as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6408 fi
6409 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6410 $as_echo "$tool_specified" >&6; }
6411 fi
6412 fi
6413 fi
6414
6415
6416
6417 if test "x$DIFF" = x; then
6418 as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6419 fi
6420
6421
6422
6423
6424
6425 # Publish this variable in the help.
6426
6427
6428 if test "x$DIRNAME" = x; then
6429 # The variable is not set by user, try to locate tool using the code snippet
6430 for ac_prog in dirname
6431 do
6432 # Extract the first word of "$ac_prog", so it can be a program name with args.
6433 set dummy $ac_prog; ac_word=$2
6434 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6435 $as_echo_n "checking for $ac_word... " >&6; }
6436 if ${ac_cv_path_DIRNAME+:} false; then :
6437 $as_echo_n "(cached) " >&6
6438 else
6439 case $DIRNAME in
6440 [\\/]* | ?:[\\/]*)
6441 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6442 ;;
6443 *)
6444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6445 for as_dir in $PATH
6446 do
6447 IFS=$as_save_IFS
6448 test -z "$as_dir" && as_dir=.
6449 for ac_exec_ext in '' $ac_executable_extensions; do
6450 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6451 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6452 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6453 break 2
6454 fi
6455 done
6456 done
6457 IFS=$as_save_IFS
6458
6459 ;;
6460 esac
6461 fi
6462 DIRNAME=$ac_cv_path_DIRNAME
6463 if test -n "$DIRNAME"; then
6464 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6465 $as_echo "$DIRNAME" >&6; }
6466 else
6467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6468 $as_echo "no" >&6; }
6469 fi
6470
6471
6472 test -n "$DIRNAME" && break
6473 done
6474
6475 else
6476 # The variable is set, but is it from the command line or the environment?
6477
6478 # Try to remove the string !DIRNAME! from our list.
6479 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6480 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6481 # If it failed, the variable was not from the command line. Ignore it,
6482 # but warn the user (except for BASH, which is always set by the calling BASH).
6483 if test "xDIRNAME" != xBASH; then
6484 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6485 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6486 fi
6487 # Try to locate tool using the code snippet
6488 for ac_prog in dirname
6489 do
6490 # Extract the first word of "$ac_prog", so it can be a program name with args.
6491 set dummy $ac_prog; ac_word=$2
6492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6493 $as_echo_n "checking for $ac_word... " >&6; }
6494 if ${ac_cv_path_DIRNAME+:} false; then :
6495 $as_echo_n "(cached) " >&6
6496 else
6497 case $DIRNAME in
6498 [\\/]* | ?:[\\/]*)
6499 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6500 ;;
6501 *)
6502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6503 for as_dir in $PATH
6504 do
6505 IFS=$as_save_IFS
6506 test -z "$as_dir" && as_dir=.
6507 for ac_exec_ext in '' $ac_executable_extensions; do
6508 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6509 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6510 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6511 break 2
6512 fi
6513 done
6514 done
6515 IFS=$as_save_IFS
6516
6517 ;;
6518 esac
6519 fi
6520 DIRNAME=$ac_cv_path_DIRNAME
6521 if test -n "$DIRNAME"; then
6522 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6523 $as_echo "$DIRNAME" >&6; }
6524 else
6525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6526 $as_echo "no" >&6; }
6527 fi
6528
6529
6530 test -n "$DIRNAME" && break
6531 done
6532
6533 else
6534 # If it succeeded, then it was overridden by the user. We will use it
6535 # for the tool.
6536
6537 # First remove it from the list of overridden variables, so we can test
6538 # for unknown variables in the end.
6539 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6540
6541 # Check if the provided tool contains a complete path.
6542 tool_specified="$DIRNAME"
6543 tool_basename="${tool_specified##*/}"
6544 if test "x$tool_basename" = "x$tool_specified"; then
6545 # A command without a complete path is provided, search $PATH.
6546 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6547 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6548 # Extract the first word of "$tool_basename", so it can be a program name with args.
6549 set dummy $tool_basename; ac_word=$2
6550 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6551 $as_echo_n "checking for $ac_word... " >&6; }
6552 if ${ac_cv_path_DIRNAME+:} false; then :
6553 $as_echo_n "(cached) " >&6
6554 else
6555 case $DIRNAME in
6556 [\\/]* | ?:[\\/]*)
6557 ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6558 ;;
6559 *)
6560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6561 for as_dir in $PATH
6562 do
6563 IFS=$as_save_IFS
6564 test -z "$as_dir" && as_dir=.
6565 for ac_exec_ext in '' $ac_executable_extensions; do
6566 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6567 ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6568 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6569 break 2
6570 fi
6571 done
6572 done
6573 IFS=$as_save_IFS
6574
6575 ;;
6576 esac
6577 fi
6578 DIRNAME=$ac_cv_path_DIRNAME
6579 if test -n "$DIRNAME"; then
6580 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6581 $as_echo "$DIRNAME" >&6; }
6582 else
6583 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6584 $as_echo "no" >&6; }
6585 fi
6586
6587
6588 if test "x$DIRNAME" = x; then
6589 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6590 fi
6591 else
6592 # Otherwise we believe it is a complete path. Use it as it is.
6593 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6594 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6595 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6596 $as_echo_n "checking for DIRNAME... " >&6; }
6597 if test ! -x "$tool_specified"; then
6598 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6599 $as_echo "not found" >&6; }
6600 as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6601 fi
6602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6603 $as_echo "$tool_specified" >&6; }
6604 fi
6605 fi
6606 fi
6607
6608
6609
6610 if test "x$DIRNAME" = x; then
6611 as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6612 fi
6613
6614
6615
6616
6617
6618 # Publish this variable in the help.
6619
6620
6621 if test "x$ECHO" = x; then
6622 # The variable is not set by user, try to locate tool using the code snippet
6623 for ac_prog in echo
6624 do
6625 # Extract the first word of "$ac_prog", so it can be a program name with args.
6626 set dummy $ac_prog; ac_word=$2
6627 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6628 $as_echo_n "checking for $ac_word... " >&6; }
6629 if ${ac_cv_path_ECHO+:} false; then :
6630 $as_echo_n "(cached) " >&6
6631 else
6632 case $ECHO in
6633 [\\/]* | ?:[\\/]*)
6634 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6635 ;;
6636 *)
6637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6638 for as_dir in $PATH
6639 do
6640 IFS=$as_save_IFS
6641 test -z "$as_dir" && as_dir=.
6642 for ac_exec_ext in '' $ac_executable_extensions; do
6643 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6644 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6645 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6646 break 2
6647 fi
6648 done
6649 done
6650 IFS=$as_save_IFS
6651
6652 ;;
6653 esac
6654 fi
6655 ECHO=$ac_cv_path_ECHO
6656 if test -n "$ECHO"; then
6657 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6658 $as_echo "$ECHO" >&6; }
6659 else
6660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6661 $as_echo "no" >&6; }
6662 fi
6663
6664
6665 test -n "$ECHO" && break
6666 done
6667
6668 else
6669 # The variable is set, but is it from the command line or the environment?
6670
6671 # Try to remove the string !ECHO! from our list.
6672 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6673 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6674 # If it failed, the variable was not from the command line. Ignore it,
6675 # but warn the user (except for BASH, which is always set by the calling BASH).
6676 if test "xECHO" != xBASH; then
6677 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6678 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6679 fi
6680 # Try to locate tool using the code snippet
6681 for ac_prog in echo
6682 do
6683 # Extract the first word of "$ac_prog", so it can be a program name with args.
6684 set dummy $ac_prog; ac_word=$2
6685 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6686 $as_echo_n "checking for $ac_word... " >&6; }
6687 if ${ac_cv_path_ECHO+:} false; then :
6688 $as_echo_n "(cached) " >&6
6689 else
6690 case $ECHO in
6691 [\\/]* | ?:[\\/]*)
6692 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6693 ;;
6694 *)
6695 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6696 for as_dir in $PATH
6697 do
6698 IFS=$as_save_IFS
6699 test -z "$as_dir" && as_dir=.
6700 for ac_exec_ext in '' $ac_executable_extensions; do
6701 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6702 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6703 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6704 break 2
6705 fi
6706 done
6707 done
6708 IFS=$as_save_IFS
6709
6710 ;;
6711 esac
6712 fi
6713 ECHO=$ac_cv_path_ECHO
6714 if test -n "$ECHO"; then
6715 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6716 $as_echo "$ECHO" >&6; }
6717 else
6718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6719 $as_echo "no" >&6; }
6720 fi
6721
6722
6723 test -n "$ECHO" && break
6724 done
6725
6726 else
6727 # If it succeeded, then it was overridden by the user. We will use it
6728 # for the tool.
6729
6730 # First remove it from the list of overridden variables, so we can test
6731 # for unknown variables in the end.
6732 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6733
6734 # Check if the provided tool contains a complete path.
6735 tool_specified="$ECHO"
6736 tool_basename="${tool_specified##*/}"
6737 if test "x$tool_basename" = "x$tool_specified"; then
6738 # A command without a complete path is provided, search $PATH.
6739 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6740 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6741 # Extract the first word of "$tool_basename", so it can be a program name with args.
6742 set dummy $tool_basename; ac_word=$2
6743 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6744 $as_echo_n "checking for $ac_word... " >&6; }
6745 if ${ac_cv_path_ECHO+:} false; then :
6746 $as_echo_n "(cached) " >&6
6747 else
6748 case $ECHO in
6749 [\\/]* | ?:[\\/]*)
6750 ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6751 ;;
6752 *)
6753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6754 for as_dir in $PATH
6755 do
6756 IFS=$as_save_IFS
6757 test -z "$as_dir" && as_dir=.
6758 for ac_exec_ext in '' $ac_executable_extensions; do
6759 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6760 ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6761 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6762 break 2
6763 fi
6764 done
6765 done
6766 IFS=$as_save_IFS
6767
6768 ;;
6769 esac
6770 fi
6771 ECHO=$ac_cv_path_ECHO
6772 if test -n "$ECHO"; then
6773 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6774 $as_echo "$ECHO" >&6; }
6775 else
6776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6777 $as_echo "no" >&6; }
6778 fi
6779
6780
6781 if test "x$ECHO" = x; then
6782 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6783 fi
6784 else
6785 # Otherwise we believe it is a complete path. Use it as it is.
6786 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6787 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6789 $as_echo_n "checking for ECHO... " >&6; }
6790 if test ! -x "$tool_specified"; then
6791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6792 $as_echo "not found" >&6; }
6793 as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6794 fi
6795 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6796 $as_echo "$tool_specified" >&6; }
6797 fi
6798 fi
6799 fi
6800
6801
6802
6803 if test "x$ECHO" = x; then
6804 as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6805 fi
6806
6807
6808
6809
6810
6811 # Publish this variable in the help.
6812
6813
6814 if test "x$EXPR" = x; then
6815 # The variable is not set by user, try to locate tool using the code snippet
6816 for ac_prog in expr
6817 do
6818 # Extract the first word of "$ac_prog", so it can be a program name with args.
6819 set dummy $ac_prog; ac_word=$2
6820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6821 $as_echo_n "checking for $ac_word... " >&6; }
6822 if ${ac_cv_path_EXPR+:} false; then :
6823 $as_echo_n "(cached) " >&6
6824 else
6825 case $EXPR in
6826 [\\/]* | ?:[\\/]*)
6827 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6828 ;;
6829 *)
6830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6831 for as_dir in $PATH
6832 do
6833 IFS=$as_save_IFS
6834 test -z "$as_dir" && as_dir=.
6835 for ac_exec_ext in '' $ac_executable_extensions; do
6836 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6837 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6838 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6839 break 2
6840 fi
6841 done
6842 done
6843 IFS=$as_save_IFS
6844
6845 ;;
6846 esac
6847 fi
6848 EXPR=$ac_cv_path_EXPR
6849 if test -n "$EXPR"; then
6850 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6851 $as_echo "$EXPR" >&6; }
6852 else
6853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6854 $as_echo "no" >&6; }
6855 fi
6856
6857
6858 test -n "$EXPR" && break
6859 done
6860
6861 else
6862 # The variable is set, but is it from the command line or the environment?
6863
6864 # Try to remove the string !EXPR! from our list.
6865 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6866 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6867 # If it failed, the variable was not from the command line. Ignore it,
6868 # but warn the user (except for BASH, which is always set by the calling BASH).
6869 if test "xEXPR" != xBASH; then
6870 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6871 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6872 fi
6873 # Try to locate tool using the code snippet
6874 for ac_prog in expr
6875 do
6876 # Extract the first word of "$ac_prog", so it can be a program name with args.
6877 set dummy $ac_prog; ac_word=$2
6878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6879 $as_echo_n "checking for $ac_word... " >&6; }
6880 if ${ac_cv_path_EXPR+:} false; then :
6881 $as_echo_n "(cached) " >&6
6882 else
6883 case $EXPR in
6884 [\\/]* | ?:[\\/]*)
6885 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6886 ;;
6887 *)
6888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6889 for as_dir in $PATH
6890 do
6891 IFS=$as_save_IFS
6892 test -z "$as_dir" && as_dir=.
6893 for ac_exec_ext in '' $ac_executable_extensions; do
6894 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6895 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6896 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6897 break 2
6898 fi
6899 done
6900 done
6901 IFS=$as_save_IFS
6902
6903 ;;
6904 esac
6905 fi
6906 EXPR=$ac_cv_path_EXPR
6907 if test -n "$EXPR"; then
6908 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6909 $as_echo "$EXPR" >&6; }
6910 else
6911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6912 $as_echo "no" >&6; }
6913 fi
6914
6915
6916 test -n "$EXPR" && break
6917 done
6918
6919 else
6920 # If it succeeded, then it was overridden by the user. We will use it
6921 # for the tool.
6922
6923 # First remove it from the list of overridden variables, so we can test
6924 # for unknown variables in the end.
6925 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6926
6927 # Check if the provided tool contains a complete path.
6928 tool_specified="$EXPR"
6929 tool_basename="${tool_specified##*/}"
6930 if test "x$tool_basename" = "x$tool_specified"; then
6931 # A command without a complete path is provided, search $PATH.
6932 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6933 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6934 # Extract the first word of "$tool_basename", so it can be a program name with args.
6935 set dummy $tool_basename; ac_word=$2
6936 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6937 $as_echo_n "checking for $ac_word... " >&6; }
6938 if ${ac_cv_path_EXPR+:} false; then :
6939 $as_echo_n "(cached) " >&6
6940 else
6941 case $EXPR in
6942 [\\/]* | ?:[\\/]*)
6943 ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6944 ;;
6945 *)
6946 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6947 for as_dir in $PATH
6948 do
6949 IFS=$as_save_IFS
6950 test -z "$as_dir" && as_dir=.
6951 for ac_exec_ext in '' $ac_executable_extensions; do
6952 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6953 ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6954 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6955 break 2
6956 fi
6957 done
6958 done
6959 IFS=$as_save_IFS
6960
6961 ;;
6962 esac
6963 fi
6964 EXPR=$ac_cv_path_EXPR
6965 if test -n "$EXPR"; then
6966 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6967 $as_echo "$EXPR" >&6; }
6968 else
6969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6970 $as_echo "no" >&6; }
6971 fi
6972
6973
6974 if test "x$EXPR" = x; then
6975 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6976 fi
6977 else
6978 # Otherwise we believe it is a complete path. Use it as it is.
6979 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6980 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6981 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6982 $as_echo_n "checking for EXPR... " >&6; }
6983 if test ! -x "$tool_specified"; then
6984 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6985 $as_echo "not found" >&6; }
6986 as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6987 fi
6988 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6989 $as_echo "$tool_specified" >&6; }
6990 fi
6991 fi
6992 fi
6993
6994
6995
6996 if test "x$EXPR" = x; then
6997 as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6998 fi
6999
7000
7001
7002
7003
7004 # Publish this variable in the help.
7005
7006
7007 if test "x$FILE" = x; then
7008 # The variable is not set by user, try to locate tool using the code snippet
7009 for ac_prog in file
7010 do
7011 # Extract the first word of "$ac_prog", so it can be a program name with args.
7012 set dummy $ac_prog; ac_word=$2
7013 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7014 $as_echo_n "checking for $ac_word... " >&6; }
7015 if ${ac_cv_path_FILE+:} false; then :
7016 $as_echo_n "(cached) " >&6
7017 else
7018 case $FILE in
7019 [\\/]* | ?:[\\/]*)
7020 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7021 ;;
7022 *)
7023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7024 for as_dir in $PATH
7025 do
7026 IFS=$as_save_IFS
7027 test -z "$as_dir" && as_dir=.
7028 for ac_exec_ext in '' $ac_executable_extensions; do
7029 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7030 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7031 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7032 break 2
7033 fi
7034 done
7035 done
7036 IFS=$as_save_IFS
7037
7038 ;;
7039 esac
7040 fi
7041 FILE=$ac_cv_path_FILE
7042 if test -n "$FILE"; then
7043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7044 $as_echo "$FILE" >&6; }
7045 else
7046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7047 $as_echo "no" >&6; }
7048 fi
7049
7050
7051 test -n "$FILE" && break
7052 done
7053
7054 else
7055 # The variable is set, but is it from the command line or the environment?
7056
7057 # Try to remove the string !FILE! from our list.
7058 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7059 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7060 # If it failed, the variable was not from the command line. Ignore it,
7061 # but warn the user (except for BASH, which is always set by the calling BASH).
7062 if test "xFILE" != xBASH; then
7063 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7064 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7065 fi
7066 # Try to locate tool using the code snippet
7067 for ac_prog in file
7068 do
7069 # Extract the first word of "$ac_prog", so it can be a program name with args.
7070 set dummy $ac_prog; ac_word=$2
7071 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7072 $as_echo_n "checking for $ac_word... " >&6; }
7073 if ${ac_cv_path_FILE+:} false; then :
7074 $as_echo_n "(cached) " >&6
7075 else
7076 case $FILE in
7077 [\\/]* | ?:[\\/]*)
7078 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7079 ;;
7080 *)
7081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7082 for as_dir in $PATH
7083 do
7084 IFS=$as_save_IFS
7085 test -z "$as_dir" && as_dir=.
7086 for ac_exec_ext in '' $ac_executable_extensions; do
7087 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7088 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7089 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7090 break 2
7091 fi
7092 done
7093 done
7094 IFS=$as_save_IFS
7095
7096 ;;
7097 esac
7098 fi
7099 FILE=$ac_cv_path_FILE
7100 if test -n "$FILE"; then
7101 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7102 $as_echo "$FILE" >&6; }
7103 else
7104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7105 $as_echo "no" >&6; }
7106 fi
7107
7108
7109 test -n "$FILE" && break
7110 done
7111
7112 else
7113 # If it succeeded, then it was overridden by the user. We will use it
7114 # for the tool.
7115
7116 # First remove it from the list of overridden variables, so we can test
7117 # for unknown variables in the end.
7118 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7119
7120 # Check if the provided tool contains a complete path.
7121 tool_specified="$FILE"
7122 tool_basename="${tool_specified##*/}"
7123 if test "x$tool_basename" = "x$tool_specified"; then
7124 # A command without a complete path is provided, search $PATH.
7125 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7126 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7127 # Extract the first word of "$tool_basename", so it can be a program name with args.
7128 set dummy $tool_basename; ac_word=$2
7129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7130 $as_echo_n "checking for $ac_word... " >&6; }
7131 if ${ac_cv_path_FILE+:} false; then :
7132 $as_echo_n "(cached) " >&6
7133 else
7134 case $FILE in
7135 [\\/]* | ?:[\\/]*)
7136 ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7137 ;;
7138 *)
7139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7140 for as_dir in $PATH
7141 do
7142 IFS=$as_save_IFS
7143 test -z "$as_dir" && as_dir=.
7144 for ac_exec_ext in '' $ac_executable_extensions; do
7145 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7146 ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7147 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7148 break 2
7149 fi
7150 done
7151 done
7152 IFS=$as_save_IFS
7153
7154 ;;
7155 esac
7156 fi
7157 FILE=$ac_cv_path_FILE
7158 if test -n "$FILE"; then
7159 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7160 $as_echo "$FILE" >&6; }
7161 else
7162 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7163 $as_echo "no" >&6; }
7164 fi
7165
7166
7167 if test "x$FILE" = x; then
7168 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7169 fi
7170 else
7171 # Otherwise we believe it is a complete path. Use it as it is.
7172 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7173 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7175 $as_echo_n "checking for FILE... " >&6; }
7176 if test ! -x "$tool_specified"; then
7177 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7178 $as_echo "not found" >&6; }
7179 as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7180 fi
7181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7182 $as_echo "$tool_specified" >&6; }
7183 fi
7184 fi
7185 fi
7186
7187
7188
7189 if test "x$FILE" = x; then
7190 as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7191 fi
7192
7193
7194
7195
7196
7197 # Publish this variable in the help.
7198
7199
7200 if test "x$FIND" = x; then
7201 # The variable is not set by user, try to locate tool using the code snippet
7202 for ac_prog in find
7203 do
7204 # Extract the first word of "$ac_prog", so it can be a program name with args.
7205 set dummy $ac_prog; ac_word=$2
7206 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7207 $as_echo_n "checking for $ac_word... " >&6; }
7208 if ${ac_cv_path_FIND+:} false; then :
7209 $as_echo_n "(cached) " >&6
7210 else
7211 case $FIND in
7212 [\\/]* | ?:[\\/]*)
7213 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7214 ;;
7215 *)
7216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7217 for as_dir in $PATH
7218 do
7219 IFS=$as_save_IFS
7220 test -z "$as_dir" && as_dir=.
7221 for ac_exec_ext in '' $ac_executable_extensions; do
7222 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7223 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7224 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7225 break 2
7226 fi
7227 done
7228 done
7229 IFS=$as_save_IFS
7230
7231 ;;
7232 esac
7233 fi
7234 FIND=$ac_cv_path_FIND
7235 if test -n "$FIND"; then
7236 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7237 $as_echo "$FIND" >&6; }
7238 else
7239 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7240 $as_echo "no" >&6; }
7241 fi
7242
7243
7244 test -n "$FIND" && break
7245 done
7246
7247 else
7248 # The variable is set, but is it from the command line or the environment?
7249
7250 # Try to remove the string !FIND! from our list.
7251 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7252 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7253 # If it failed, the variable was not from the command line. Ignore it,
7254 # but warn the user (except for BASH, which is always set by the calling BASH).
7255 if test "xFIND" != xBASH; then
7256 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7257 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7258 fi
7259 # Try to locate tool using the code snippet
7260 for ac_prog in find
7261 do
7262 # Extract the first word of "$ac_prog", so it can be a program name with args.
7263 set dummy $ac_prog; ac_word=$2
7264 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7265 $as_echo_n "checking for $ac_word... " >&6; }
7266 if ${ac_cv_path_FIND+:} false; then :
7267 $as_echo_n "(cached) " >&6
7268 else
7269 case $FIND in
7270 [\\/]* | ?:[\\/]*)
7271 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7272 ;;
7273 *)
7274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7275 for as_dir in $PATH
7276 do
7277 IFS=$as_save_IFS
7278 test -z "$as_dir" && as_dir=.
7279 for ac_exec_ext in '' $ac_executable_extensions; do
7280 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7281 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7282 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7283 break 2
7284 fi
7285 done
7286 done
7287 IFS=$as_save_IFS
7288
7289 ;;
7290 esac
7291 fi
7292 FIND=$ac_cv_path_FIND
7293 if test -n "$FIND"; then
7294 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7295 $as_echo "$FIND" >&6; }
7296 else
7297 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7298 $as_echo "no" >&6; }
7299 fi
7300
7301
7302 test -n "$FIND" && break
7303 done
7304
7305 else
7306 # If it succeeded, then it was overridden by the user. We will use it
7307 # for the tool.
7308
7309 # First remove it from the list of overridden variables, so we can test
7310 # for unknown variables in the end.
7311 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7312
7313 # Check if the provided tool contains a complete path.
7314 tool_specified="$FIND"
7315 tool_basename="${tool_specified##*/}"
7316 if test "x$tool_basename" = "x$tool_specified"; then
7317 # A command without a complete path is provided, search $PATH.
7318 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7319 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7320 # Extract the first word of "$tool_basename", so it can be a program name with args.
7321 set dummy $tool_basename; ac_word=$2
7322 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7323 $as_echo_n "checking for $ac_word... " >&6; }
7324 if ${ac_cv_path_FIND+:} false; then :
7325 $as_echo_n "(cached) " >&6
7326 else
7327 case $FIND in
7328 [\\/]* | ?:[\\/]*)
7329 ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7330 ;;
7331 *)
7332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7333 for as_dir in $PATH
7334 do
7335 IFS=$as_save_IFS
7336 test -z "$as_dir" && as_dir=.
7337 for ac_exec_ext in '' $ac_executable_extensions; do
7338 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7339 ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7340 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7341 break 2
7342 fi
7343 done
7344 done
7345 IFS=$as_save_IFS
7346
7347 ;;
7348 esac
7349 fi
7350 FIND=$ac_cv_path_FIND
7351 if test -n "$FIND"; then
7352 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7353 $as_echo "$FIND" >&6; }
7354 else
7355 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7356 $as_echo "no" >&6; }
7357 fi
7358
7359
7360 if test "x$FIND" = x; then
7361 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7362 fi
7363 else
7364 # Otherwise we believe it is a complete path. Use it as it is.
7365 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7366 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7368 $as_echo_n "checking for FIND... " >&6; }
7369 if test ! -x "$tool_specified"; then
7370 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7371 $as_echo "not found" >&6; }
7372 as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7373 fi
7374 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7375 $as_echo "$tool_specified" >&6; }
7376 fi
7377 fi
7378 fi
7379
7380
7381
7382 if test "x$FIND" = x; then
7383 as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7384 fi
7385
7386
7387
7388
7389
7390 # Publish this variable in the help.
7391
7392
7393 if test "x$HEAD" = x; then
7394 # The variable is not set by user, try to locate tool using the code snippet
7395 for ac_prog in head
7396 do
7397 # Extract the first word of "$ac_prog", so it can be a program name with args.
7398 set dummy $ac_prog; ac_word=$2
7399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7400 $as_echo_n "checking for $ac_word... " >&6; }
7401 if ${ac_cv_path_HEAD+:} false; then :
7402 $as_echo_n "(cached) " >&6
7403 else
7404 case $HEAD in
7405 [\\/]* | ?:[\\/]*)
7406 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7407 ;;
7408 *)
7409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7410 for as_dir in $PATH
7411 do
7412 IFS=$as_save_IFS
7413 test -z "$as_dir" && as_dir=.
7414 for ac_exec_ext in '' $ac_executable_extensions; do
7415 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7416 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7417 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7418 break 2
7419 fi
7420 done
7421 done
7422 IFS=$as_save_IFS
7423
7424 ;;
7425 esac
7426 fi
7427 HEAD=$ac_cv_path_HEAD
7428 if test -n "$HEAD"; then
7429 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7430 $as_echo "$HEAD" >&6; }
7431 else
7432 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7433 $as_echo "no" >&6; }
7434 fi
7435
7436
7437 test -n "$HEAD" && break
7438 done
7439
7440 else
7441 # The variable is set, but is it from the command line or the environment?
7442
7443 # Try to remove the string !HEAD! from our list.
7444 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7445 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7446 # If it failed, the variable was not from the command line. Ignore it,
7447 # but warn the user (except for BASH, which is always set by the calling BASH).
7448 if test "xHEAD" != xBASH; then
7449 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7450 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7451 fi
7452 # Try to locate tool using the code snippet
7453 for ac_prog in head
7454 do
7455 # Extract the first word of "$ac_prog", so it can be a program name with args.
7456 set dummy $ac_prog; ac_word=$2
7457 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7458 $as_echo_n "checking for $ac_word... " >&6; }
7459 if ${ac_cv_path_HEAD+:} false; then :
7460 $as_echo_n "(cached) " >&6
7461 else
7462 case $HEAD in
7463 [\\/]* | ?:[\\/]*)
7464 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7465 ;;
7466 *)
7467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7468 for as_dir in $PATH
7469 do
7470 IFS=$as_save_IFS
7471 test -z "$as_dir" && as_dir=.
7472 for ac_exec_ext in '' $ac_executable_extensions; do
7473 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7474 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7475 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7476 break 2
7477 fi
7478 done
7479 done
7480 IFS=$as_save_IFS
7481
7482 ;;
7483 esac
7484 fi
7485 HEAD=$ac_cv_path_HEAD
7486 if test -n "$HEAD"; then
7487 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7488 $as_echo "$HEAD" >&6; }
7489 else
7490 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7491 $as_echo "no" >&6; }
7492 fi
7493
7494
7495 test -n "$HEAD" && break
7496 done
7497
7498 else
7499 # If it succeeded, then it was overridden by the user. We will use it
7500 # for the tool.
7501
7502 # First remove it from the list of overridden variables, so we can test
7503 # for unknown variables in the end.
7504 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7505
7506 # Check if the provided tool contains a complete path.
7507 tool_specified="$HEAD"
7508 tool_basename="${tool_specified##*/}"
7509 if test "x$tool_basename" = "x$tool_specified"; then
7510 # A command without a complete path is provided, search $PATH.
7511 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7512 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7513 # Extract the first word of "$tool_basename", so it can be a program name with args.
7514 set dummy $tool_basename; ac_word=$2
7515 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7516 $as_echo_n "checking for $ac_word... " >&6; }
7517 if ${ac_cv_path_HEAD+:} false; then :
7518 $as_echo_n "(cached) " >&6
7519 else
7520 case $HEAD in
7521 [\\/]* | ?:[\\/]*)
7522 ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7523 ;;
7524 *)
7525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7526 for as_dir in $PATH
7527 do
7528 IFS=$as_save_IFS
7529 test -z "$as_dir" && as_dir=.
7530 for ac_exec_ext in '' $ac_executable_extensions; do
7531 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7532 ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7533 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7534 break 2
7535 fi
7536 done
7537 done
7538 IFS=$as_save_IFS
7539
7540 ;;
7541 esac
7542 fi
7543 HEAD=$ac_cv_path_HEAD
7544 if test -n "$HEAD"; then
7545 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7546 $as_echo "$HEAD" >&6; }
7547 else
7548 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7549 $as_echo "no" >&6; }
7550 fi
7551
7552
7553 if test "x$HEAD" = x; then
7554 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7555 fi
7556 else
7557 # Otherwise we believe it is a complete path. Use it as it is.
7558 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7559 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7561 $as_echo_n "checking for HEAD... " >&6; }
7562 if test ! -x "$tool_specified"; then
7563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7564 $as_echo "not found" >&6; }
7565 as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7566 fi
7567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7568 $as_echo "$tool_specified" >&6; }
7569 fi
7570 fi
7571 fi
7572
7573
7574
7575 if test "x$HEAD" = x; then
7576 as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7577 fi
7578
7579
7580
7581
7582
7583 # Publish this variable in the help.
7584
7585
7586 if test "x$LN" = x; then
7587 # The variable is not set by user, try to locate tool using the code snippet
7588 for ac_prog in ln
7589 do
7590 # Extract the first word of "$ac_prog", so it can be a program name with args.
7591 set dummy $ac_prog; ac_word=$2
7592 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7593 $as_echo_n "checking for $ac_word... " >&6; }
7594 if ${ac_cv_path_LN+:} false; then :
7595 $as_echo_n "(cached) " >&6
7596 else
7597 case $LN in
7598 [\\/]* | ?:[\\/]*)
7599 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7600 ;;
7601 *)
7602 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7603 for as_dir in $PATH
7604 do
7605 IFS=$as_save_IFS
7606 test -z "$as_dir" && as_dir=.
7607 for ac_exec_ext in '' $ac_executable_extensions; do
7608 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7609 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7610 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7611 break 2
7612 fi
7613 done
7614 done
7615 IFS=$as_save_IFS
7616
7617 ;;
7618 esac
7619 fi
7620 LN=$ac_cv_path_LN
7621 if test -n "$LN"; then
7622 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7623 $as_echo "$LN" >&6; }
7624 else
7625 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7626 $as_echo "no" >&6; }
7627 fi
7628
7629
7630 test -n "$LN" && break
7631 done
7632
7633 else
7634 # The variable is set, but is it from the command line or the environment?
7635
7636 # Try to remove the string !LN! from our list.
7637 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7638 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7639 # If it failed, the variable was not from the command line. Ignore it,
7640 # but warn the user (except for BASH, which is always set by the calling BASH).
7641 if test "xLN" != xBASH; then
7642 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7643 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7644 fi
7645 # Try to locate tool using the code snippet
7646 for ac_prog in ln
7647 do
7648 # Extract the first word of "$ac_prog", so it can be a program name with args.
7649 set dummy $ac_prog; ac_word=$2
7650 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7651 $as_echo_n "checking for $ac_word... " >&6; }
7652 if ${ac_cv_path_LN+:} false; then :
7653 $as_echo_n "(cached) " >&6
7654 else
7655 case $LN in
7656 [\\/]* | ?:[\\/]*)
7657 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7658 ;;
7659 *)
7660 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7661 for as_dir in $PATH
7662 do
7663 IFS=$as_save_IFS
7664 test -z "$as_dir" && as_dir=.
7665 for ac_exec_ext in '' $ac_executable_extensions; do
7666 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7667 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7668 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7669 break 2
7670 fi
7671 done
7672 done
7673 IFS=$as_save_IFS
7674
7675 ;;
7676 esac
7677 fi
7678 LN=$ac_cv_path_LN
7679 if test -n "$LN"; then
7680 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7681 $as_echo "$LN" >&6; }
7682 else
7683 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7684 $as_echo "no" >&6; }
7685 fi
7686
7687
7688 test -n "$LN" && break
7689 done
7690
7691 else
7692 # If it succeeded, then it was overridden by the user. We will use it
7693 # for the tool.
7694
7695 # First remove it from the list of overridden variables, so we can test
7696 # for unknown variables in the end.
7697 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7698
7699 # Check if the provided tool contains a complete path.
7700 tool_specified="$LN"
7701 tool_basename="${tool_specified##*/}"
7702 if test "x$tool_basename" = "x$tool_specified"; then
7703 # A command without a complete path is provided, search $PATH.
7704 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7705 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7706 # Extract the first word of "$tool_basename", so it can be a program name with args.
7707 set dummy $tool_basename; ac_word=$2
7708 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7709 $as_echo_n "checking for $ac_word... " >&6; }
7710 if ${ac_cv_path_LN+:} false; then :
7711 $as_echo_n "(cached) " >&6
7712 else
7713 case $LN in
7714 [\\/]* | ?:[\\/]*)
7715 ac_cv_path_LN="$LN" # Let the user override the test with a path.
7716 ;;
7717 *)
7718 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7719 for as_dir in $PATH
7720 do
7721 IFS=$as_save_IFS
7722 test -z "$as_dir" && as_dir=.
7723 for ac_exec_ext in '' $ac_executable_extensions; do
7724 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7725 ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7726 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7727 break 2
7728 fi
7729 done
7730 done
7731 IFS=$as_save_IFS
7732
7733 ;;
7734 esac
7735 fi
7736 LN=$ac_cv_path_LN
7737 if test -n "$LN"; then
7738 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7739 $as_echo "$LN" >&6; }
7740 else
7741 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7742 $as_echo "no" >&6; }
7743 fi
7744
7745
7746 if test "x$LN" = x; then
7747 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7748 fi
7749 else
7750 # Otherwise we believe it is a complete path. Use it as it is.
7751 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7752 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7754 $as_echo_n "checking for LN... " >&6; }
7755 if test ! -x "$tool_specified"; then
7756 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7757 $as_echo "not found" >&6; }
7758 as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7759 fi
7760 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7761 $as_echo "$tool_specified" >&6; }
7762 fi
7763 fi
7764 fi
7765
7766
7767
7768 if test "x$LN" = x; then
7769 as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7770 fi
7771
7772
7773
7774
7775
7776 # Publish this variable in the help.
7777
7778
7779 if test "x$LS" = x; then
7780 # The variable is not set by user, try to locate tool using the code snippet
7781 for ac_prog in ls
7782 do
7783 # Extract the first word of "$ac_prog", so it can be a program name with args.
7784 set dummy $ac_prog; ac_word=$2
7785 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7786 $as_echo_n "checking for $ac_word... " >&6; }
7787 if ${ac_cv_path_LS+:} false; then :
7788 $as_echo_n "(cached) " >&6
7789 else
7790 case $LS in
7791 [\\/]* | ?:[\\/]*)
7792 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7793 ;;
7794 *)
7795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7796 for as_dir in $PATH
7797 do
7798 IFS=$as_save_IFS
7799 test -z "$as_dir" && as_dir=.
7800 for ac_exec_ext in '' $ac_executable_extensions; do
7801 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7802 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7803 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7804 break 2
7805 fi
7806 done
7807 done
7808 IFS=$as_save_IFS
7809
7810 ;;
7811 esac
7812 fi
7813 LS=$ac_cv_path_LS
7814 if test -n "$LS"; then
7815 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7816 $as_echo "$LS" >&6; }
7817 else
7818 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7819 $as_echo "no" >&6; }
7820 fi
7821
7822
7823 test -n "$LS" && break
7824 done
7825
7826 else
7827 # The variable is set, but is it from the command line or the environment?
7828
7829 # Try to remove the string !LS! from our list.
7830 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7831 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7832 # If it failed, the variable was not from the command line. Ignore it,
7833 # but warn the user (except for BASH, which is always set by the calling BASH).
7834 if test "xLS" != xBASH; then
7835 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7836 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7837 fi
7838 # Try to locate tool using the code snippet
7839 for ac_prog in ls
7840 do
7841 # Extract the first word of "$ac_prog", so it can be a program name with args.
7842 set dummy $ac_prog; ac_word=$2
7843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7844 $as_echo_n "checking for $ac_word... " >&6; }
7845 if ${ac_cv_path_LS+:} false; then :
7846 $as_echo_n "(cached) " >&6
7847 else
7848 case $LS in
7849 [\\/]* | ?:[\\/]*)
7850 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7851 ;;
7852 *)
7853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7854 for as_dir in $PATH
7855 do
7856 IFS=$as_save_IFS
7857 test -z "$as_dir" && as_dir=.
7858 for ac_exec_ext in '' $ac_executable_extensions; do
7859 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7860 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7861 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7862 break 2
7863 fi
7864 done
7865 done
7866 IFS=$as_save_IFS
7867
7868 ;;
7869 esac
7870 fi
7871 LS=$ac_cv_path_LS
7872 if test -n "$LS"; then
7873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7874 $as_echo "$LS" >&6; }
7875 else
7876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7877 $as_echo "no" >&6; }
7878 fi
7879
7880
7881 test -n "$LS" && break
7882 done
7883
7884 else
7885 # If it succeeded, then it was overridden by the user. We will use it
7886 # for the tool.
7887
7888 # First remove it from the list of overridden variables, so we can test
7889 # for unknown variables in the end.
7890 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7891
7892 # Check if the provided tool contains a complete path.
7893 tool_specified="$LS"
7894 tool_basename="${tool_specified##*/}"
7895 if test "x$tool_basename" = "x$tool_specified"; then
7896 # A command without a complete path is provided, search $PATH.
7897 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7898 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7899 # Extract the first word of "$tool_basename", so it can be a program name with args.
7900 set dummy $tool_basename; ac_word=$2
7901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7902 $as_echo_n "checking for $ac_word... " >&6; }
7903 if ${ac_cv_path_LS+:} false; then :
7904 $as_echo_n "(cached) " >&6
7905 else
7906 case $LS in
7907 [\\/]* | ?:[\\/]*)
7908 ac_cv_path_LS="$LS" # Let the user override the test with a path.
7909 ;;
7910 *)
7911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7912 for as_dir in $PATH
7913 do
7914 IFS=$as_save_IFS
7915 test -z "$as_dir" && as_dir=.
7916 for ac_exec_ext in '' $ac_executable_extensions; do
7917 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7918 ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7919 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7920 break 2
7921 fi
7922 done
7923 done
7924 IFS=$as_save_IFS
7925
7926 ;;
7927 esac
7928 fi
7929 LS=$ac_cv_path_LS
7930 if test -n "$LS"; then
7931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7932 $as_echo "$LS" >&6; }
7933 else
7934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7935 $as_echo "no" >&6; }
7936 fi
7937
7938
7939 if test "x$LS" = x; then
7940 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7941 fi
7942 else
7943 # Otherwise we believe it is a complete path. Use it as it is.
7944 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7945 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7947 $as_echo_n "checking for LS... " >&6; }
7948 if test ! -x "$tool_specified"; then
7949 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7950 $as_echo "not found" >&6; }
7951 as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7952 fi
7953 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7954 $as_echo "$tool_specified" >&6; }
7955 fi
7956 fi
7957 fi
7958
7959
7960
7961 if test "x$LS" = x; then
7962 as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7963 fi
7964
7965
7966
7967
7968
7969 # Publish this variable in the help.
7970
7971
7972 if test "x$MKDIR" = x; then
7973 # The variable is not set by user, try to locate tool using the code snippet
7974 for ac_prog in mkdir
7975 do
7976 # Extract the first word of "$ac_prog", so it can be a program name with args.
7977 set dummy $ac_prog; ac_word=$2
7978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7979 $as_echo_n "checking for $ac_word... " >&6; }
7980 if ${ac_cv_path_MKDIR+:} false; then :
7981 $as_echo_n "(cached) " >&6
7982 else
7983 case $MKDIR in
7984 [\\/]* | ?:[\\/]*)
7985 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7986 ;;
7987 *)
7988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7989 for as_dir in $PATH
7990 do
7991 IFS=$as_save_IFS
7992 test -z "$as_dir" && as_dir=.
7993 for ac_exec_ext in '' $ac_executable_extensions; do
7994 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7995 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7996 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7997 break 2
7998 fi
7999 done
8000 done
8001 IFS=$as_save_IFS
8002
8003 ;;
8004 esac
8005 fi
8006 MKDIR=$ac_cv_path_MKDIR
8007 if test -n "$MKDIR"; then
8008 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8009 $as_echo "$MKDIR" >&6; }
8010 else
8011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8012 $as_echo "no" >&6; }
8013 fi
8014
8015
8016 test -n "$MKDIR" && break
8017 done
8018
8019 else
8020 # The variable is set, but is it from the command line or the environment?
8021
8022 # Try to remove the string !MKDIR! from our list.
8023 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8024 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8025 # If it failed, the variable was not from the command line. Ignore it,
8026 # but warn the user (except for BASH, which is always set by the calling BASH).
8027 if test "xMKDIR" != xBASH; then
8028 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8029 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8030 fi
8031 # Try to locate tool using the code snippet
8032 for ac_prog in mkdir
8033 do
8034 # Extract the first word of "$ac_prog", so it can be a program name with args.
8035 set dummy $ac_prog; ac_word=$2
8036 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8037 $as_echo_n "checking for $ac_word... " >&6; }
8038 if ${ac_cv_path_MKDIR+:} false; then :
8039 $as_echo_n "(cached) " >&6
8040 else
8041 case $MKDIR in
8042 [\\/]* | ?:[\\/]*)
8043 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8044 ;;
8045 *)
8046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8047 for as_dir in $PATH
8048 do
8049 IFS=$as_save_IFS
8050 test -z "$as_dir" && as_dir=.
8051 for ac_exec_ext in '' $ac_executable_extensions; do
8052 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8053 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8054 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8055 break 2
8056 fi
8057 done
8058 done
8059 IFS=$as_save_IFS
8060
8061 ;;
8062 esac
8063 fi
8064 MKDIR=$ac_cv_path_MKDIR
8065 if test -n "$MKDIR"; then
8066 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8067 $as_echo "$MKDIR" >&6; }
8068 else
8069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8070 $as_echo "no" >&6; }
8071 fi
8072
8073
8074 test -n "$MKDIR" && break
8075 done
8076
8077 else
8078 # If it succeeded, then it was overridden by the user. We will use it
8079 # for the tool.
8080
8081 # First remove it from the list of overridden variables, so we can test
8082 # for unknown variables in the end.
8083 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8084
8085 # Check if the provided tool contains a complete path.
8086 tool_specified="$MKDIR"
8087 tool_basename="${tool_specified##*/}"
8088 if test "x$tool_basename" = "x$tool_specified"; then
8089 # A command without a complete path is provided, search $PATH.
8090 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8091 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8092 # Extract the first word of "$tool_basename", so it can be a program name with args.
8093 set dummy $tool_basename; ac_word=$2
8094 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8095 $as_echo_n "checking for $ac_word... " >&6; }
8096 if ${ac_cv_path_MKDIR+:} false; then :
8097 $as_echo_n "(cached) " >&6
8098 else
8099 case $MKDIR in
8100 [\\/]* | ?:[\\/]*)
8101 ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8102 ;;
8103 *)
8104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8105 for as_dir in $PATH
8106 do
8107 IFS=$as_save_IFS
8108 test -z "$as_dir" && as_dir=.
8109 for ac_exec_ext in '' $ac_executable_extensions; do
8110 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8111 ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8112 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8113 break 2
8114 fi
8115 done
8116 done
8117 IFS=$as_save_IFS
8118
8119 ;;
8120 esac
8121 fi
8122 MKDIR=$ac_cv_path_MKDIR
8123 if test -n "$MKDIR"; then
8124 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8125 $as_echo "$MKDIR" >&6; }
8126 else
8127 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8128 $as_echo "no" >&6; }
8129 fi
8130
8131
8132 if test "x$MKDIR" = x; then
8133 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8134 fi
8135 else
8136 # Otherwise we believe it is a complete path. Use it as it is.
8137 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8138 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8140 $as_echo_n "checking for MKDIR... " >&6; }
8141 if test ! -x "$tool_specified"; then
8142 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8143 $as_echo "not found" >&6; }
8144 as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8145 fi
8146 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8147 $as_echo "$tool_specified" >&6; }
8148 fi
8149 fi
8150 fi
8151
8152
8153
8154 if test "x$MKDIR" = x; then
8155 as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8156 fi
8157
8158
8159
8160
8161
8162 # Publish this variable in the help.
8163
8164
8165 if test "x$MKTEMP" = x; then
8166 # The variable is not set by user, try to locate tool using the code snippet
8167 for ac_prog in mktemp
8168 do
8169 # Extract the first word of "$ac_prog", so it can be a program name with args.
8170 set dummy $ac_prog; ac_word=$2
8171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8172 $as_echo_n "checking for $ac_word... " >&6; }
8173 if ${ac_cv_path_MKTEMP+:} false; then :
8174 $as_echo_n "(cached) " >&6
8175 else
8176 case $MKTEMP in
8177 [\\/]* | ?:[\\/]*)
8178 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8179 ;;
8180 *)
8181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8182 for as_dir in $PATH
8183 do
8184 IFS=$as_save_IFS
8185 test -z "$as_dir" && as_dir=.
8186 for ac_exec_ext in '' $ac_executable_extensions; do
8187 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8188 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8189 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8190 break 2
8191 fi
8192 done
8193 done
8194 IFS=$as_save_IFS
8195
8196 ;;
8197 esac
8198 fi
8199 MKTEMP=$ac_cv_path_MKTEMP
8200 if test -n "$MKTEMP"; then
8201 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8202 $as_echo "$MKTEMP" >&6; }
8203 else
8204 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8205 $as_echo "no" >&6; }
8206 fi
8207
8208
8209 test -n "$MKTEMP" && break
8210 done
8211
8212 else
8213 # The variable is set, but is it from the command line or the environment?
8214
8215 # Try to remove the string !MKTEMP! from our list.
8216 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8217 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8218 # If it failed, the variable was not from the command line. Ignore it,
8219 # but warn the user (except for BASH, which is always set by the calling BASH).
8220 if test "xMKTEMP" != xBASH; then
8221 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8222 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8223 fi
8224 # Try to locate tool using the code snippet
8225 for ac_prog in mktemp
8226 do
8227 # Extract the first word of "$ac_prog", so it can be a program name with args.
8228 set dummy $ac_prog; ac_word=$2
8229 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8230 $as_echo_n "checking for $ac_word... " >&6; }
8231 if ${ac_cv_path_MKTEMP+:} false; then :
8232 $as_echo_n "(cached) " >&6
8233 else
8234 case $MKTEMP in
8235 [\\/]* | ?:[\\/]*)
8236 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8237 ;;
8238 *)
8239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8240 for as_dir in $PATH
8241 do
8242 IFS=$as_save_IFS
8243 test -z "$as_dir" && as_dir=.
8244 for ac_exec_ext in '' $ac_executable_extensions; do
8245 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8246 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8247 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8248 break 2
8249 fi
8250 done
8251 done
8252 IFS=$as_save_IFS
8253
8254 ;;
8255 esac
8256 fi
8257 MKTEMP=$ac_cv_path_MKTEMP
8258 if test -n "$MKTEMP"; then
8259 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8260 $as_echo "$MKTEMP" >&6; }
8261 else
8262 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8263 $as_echo "no" >&6; }
8264 fi
8265
8266
8267 test -n "$MKTEMP" && break
8268 done
8269
8270 else
8271 # If it succeeded, then it was overridden by the user. We will use it
8272 # for the tool.
8273
8274 # First remove it from the list of overridden variables, so we can test
8275 # for unknown variables in the end.
8276 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8277
8278 # Check if the provided tool contains a complete path.
8279 tool_specified="$MKTEMP"
8280 tool_basename="${tool_specified##*/}"
8281 if test "x$tool_basename" = "x$tool_specified"; then
8282 # A command without a complete path is provided, search $PATH.
8283 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8284 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8285 # Extract the first word of "$tool_basename", so it can be a program name with args.
8286 set dummy $tool_basename; ac_word=$2
8287 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8288 $as_echo_n "checking for $ac_word... " >&6; }
8289 if ${ac_cv_path_MKTEMP+:} false; then :
8290 $as_echo_n "(cached) " >&6
8291 else
8292 case $MKTEMP in
8293 [\\/]* | ?:[\\/]*)
8294 ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8295 ;;
8296 *)
8297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8298 for as_dir in $PATH
8299 do
8300 IFS=$as_save_IFS
8301 test -z "$as_dir" && as_dir=.
8302 for ac_exec_ext in '' $ac_executable_extensions; do
8303 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8304 ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8305 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8306 break 2
8307 fi
8308 done
8309 done
8310 IFS=$as_save_IFS
8311
8312 ;;
8313 esac
8314 fi
8315 MKTEMP=$ac_cv_path_MKTEMP
8316 if test -n "$MKTEMP"; then
8317 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8318 $as_echo "$MKTEMP" >&6; }
8319 else
8320 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8321 $as_echo "no" >&6; }
8322 fi
8323
8324
8325 if test "x$MKTEMP" = x; then
8326 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8327 fi
8328 else
8329 # Otherwise we believe it is a complete path. Use it as it is.
8330 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8331 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8333 $as_echo_n "checking for MKTEMP... " >&6; }
8334 if test ! -x "$tool_specified"; then
8335 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8336 $as_echo "not found" >&6; }
8337 as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8338 fi
8339 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8340 $as_echo "$tool_specified" >&6; }
8341 fi
8342 fi
8343 fi
8344
8345
8346
8347 if test "x$MKTEMP" = x; then
8348 as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8349 fi
8350
8351
8352
8353
8354
8355 # Publish this variable in the help.
8356
8357
8358 if test "x$MV" = x; then
8359 # The variable is not set by user, try to locate tool using the code snippet
8360 for ac_prog in mv
8361 do
8362 # Extract the first word of "$ac_prog", so it can be a program name with args.
8363 set dummy $ac_prog; ac_word=$2
8364 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8365 $as_echo_n "checking for $ac_word... " >&6; }
8366 if ${ac_cv_path_MV+:} false; then :
8367 $as_echo_n "(cached) " >&6
8368 else
8369 case $MV in
8370 [\\/]* | ?:[\\/]*)
8371 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8372 ;;
8373 *)
8374 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8375 for as_dir in $PATH
8376 do
8377 IFS=$as_save_IFS
8378 test -z "$as_dir" && as_dir=.
8379 for ac_exec_ext in '' $ac_executable_extensions; do
8380 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8381 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8382 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8383 break 2
8384 fi
8385 done
8386 done
8387 IFS=$as_save_IFS
8388
8389 ;;
8390 esac
8391 fi
8392 MV=$ac_cv_path_MV
8393 if test -n "$MV"; then
8394 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8395 $as_echo "$MV" >&6; }
8396 else
8397 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8398 $as_echo "no" >&6; }
8399 fi
8400
8401
8402 test -n "$MV" && break
8403 done
8404
8405 else
8406 # The variable is set, but is it from the command line or the environment?
8407
8408 # Try to remove the string !MV! from our list.
8409 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8410 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8411 # If it failed, the variable was not from the command line. Ignore it,
8412 # but warn the user (except for BASH, which is always set by the calling BASH).
8413 if test "xMV" != xBASH; then
8414 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8415 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8416 fi
8417 # Try to locate tool using the code snippet
8418 for ac_prog in mv
8419 do
8420 # Extract the first word of "$ac_prog", so it can be a program name with args.
8421 set dummy $ac_prog; ac_word=$2
8422 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8423 $as_echo_n "checking for $ac_word... " >&6; }
8424 if ${ac_cv_path_MV+:} false; then :
8425 $as_echo_n "(cached) " >&6
8426 else
8427 case $MV in
8428 [\\/]* | ?:[\\/]*)
8429 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8430 ;;
8431 *)
8432 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8433 for as_dir in $PATH
8434 do
8435 IFS=$as_save_IFS
8436 test -z "$as_dir" && as_dir=.
8437 for ac_exec_ext in '' $ac_executable_extensions; do
8438 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8439 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8440 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8441 break 2
8442 fi
8443 done
8444 done
8445 IFS=$as_save_IFS
8446
8447 ;;
8448 esac
8449 fi
8450 MV=$ac_cv_path_MV
8451 if test -n "$MV"; then
8452 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8453 $as_echo "$MV" >&6; }
8454 else
8455 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8456 $as_echo "no" >&6; }
8457 fi
8458
8459
8460 test -n "$MV" && break
8461 done
8462
8463 else
8464 # If it succeeded, then it was overridden by the user. We will use it
8465 # for the tool.
8466
8467 # First remove it from the list of overridden variables, so we can test
8468 # for unknown variables in the end.
8469 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8470
8471 # Check if the provided tool contains a complete path.
8472 tool_specified="$MV"
8473 tool_basename="${tool_specified##*/}"
8474 if test "x$tool_basename" = "x$tool_specified"; then
8475 # A command without a complete path is provided, search $PATH.
8476 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8477 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8478 # Extract the first word of "$tool_basename", so it can be a program name with args.
8479 set dummy $tool_basename; ac_word=$2
8480 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8481 $as_echo_n "checking for $ac_word... " >&6; }
8482 if ${ac_cv_path_MV+:} false; then :
8483 $as_echo_n "(cached) " >&6
8484 else
8485 case $MV in
8486 [\\/]* | ?:[\\/]*)
8487 ac_cv_path_MV="$MV" # Let the user override the test with a path.
8488 ;;
8489 *)
8490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8491 for as_dir in $PATH
8492 do
8493 IFS=$as_save_IFS
8494 test -z "$as_dir" && as_dir=.
8495 for ac_exec_ext in '' $ac_executable_extensions; do
8496 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8497 ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8498 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8499 break 2
8500 fi
8501 done
8502 done
8503 IFS=$as_save_IFS
8504
8505 ;;
8506 esac
8507 fi
8508 MV=$ac_cv_path_MV
8509 if test -n "$MV"; then
8510 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8511 $as_echo "$MV" >&6; }
8512 else
8513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8514 $as_echo "no" >&6; }
8515 fi
8516
8517
8518 if test "x$MV" = x; then
8519 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8520 fi
8521 else
8522 # Otherwise we believe it is a complete path. Use it as it is.
8523 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8524 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8526 $as_echo_n "checking for MV... " >&6; }
8527 if test ! -x "$tool_specified"; then
8528 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8529 $as_echo "not found" >&6; }
8530 as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8531 fi
8532 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8533 $as_echo "$tool_specified" >&6; }
8534 fi
8535 fi
8536 fi
8537
8538
8539
8540 if test "x$MV" = x; then
8541 as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8542 fi
8543
8544
8545
8546
8547
8548 # Publish this variable in the help.
8549
8550
8551 if test "x$NAWK" = x; then
8552 # The variable is not set by user, try to locate tool using the code snippet
8553 for ac_prog in nawk gawk awk
8554 do
8555 # Extract the first word of "$ac_prog", so it can be a program name with args.
8556 set dummy $ac_prog; ac_word=$2
8557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8558 $as_echo_n "checking for $ac_word... " >&6; }
8559 if ${ac_cv_path_NAWK+:} false; then :
8560 $as_echo_n "(cached) " >&6
8561 else
8562 case $NAWK in
8563 [\\/]* | ?:[\\/]*)
8564 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8565 ;;
8566 *)
8567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8568 for as_dir in $PATH
8569 do
8570 IFS=$as_save_IFS
8571 test -z "$as_dir" && as_dir=.
8572 for ac_exec_ext in '' $ac_executable_extensions; do
8573 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8574 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8575 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8576 break 2
8577 fi
8578 done
8579 done
8580 IFS=$as_save_IFS
8581
8582 ;;
8583 esac
8584 fi
8585 NAWK=$ac_cv_path_NAWK
8586 if test -n "$NAWK"; then
8587 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8588 $as_echo "$NAWK" >&6; }
8589 else
8590 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8591 $as_echo "no" >&6; }
8592 fi
8593
8594
8595 test -n "$NAWK" && break
8596 done
8597
8598 else
8599 # The variable is set, but is it from the command line or the environment?
8600
8601 # Try to remove the string !NAWK! from our list.
8602 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8603 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8604 # If it failed, the variable was not from the command line. Ignore it,
8605 # but warn the user (except for BASH, which is always set by the calling BASH).
8606 if test "xNAWK" != xBASH; then
8607 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8608 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8609 fi
8610 # Try to locate tool using the code snippet
8611 for ac_prog in nawk gawk awk
8612 do
8613 # Extract the first word of "$ac_prog", so it can be a program name with args.
8614 set dummy $ac_prog; ac_word=$2
8615 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8616 $as_echo_n "checking for $ac_word... " >&6; }
8617 if ${ac_cv_path_NAWK+:} false; then :
8618 $as_echo_n "(cached) " >&6
8619 else
8620 case $NAWK in
8621 [\\/]* | ?:[\\/]*)
8622 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8623 ;;
8624 *)
8625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8626 for as_dir in $PATH
8627 do
8628 IFS=$as_save_IFS
8629 test -z "$as_dir" && as_dir=.
8630 for ac_exec_ext in '' $ac_executable_extensions; do
8631 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8632 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8633 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8634 break 2
8635 fi
8636 done
8637 done
8638 IFS=$as_save_IFS
8639
8640 ;;
8641 esac
8642 fi
8643 NAWK=$ac_cv_path_NAWK
8644 if test -n "$NAWK"; then
8645 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8646 $as_echo "$NAWK" >&6; }
8647 else
8648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8649 $as_echo "no" >&6; }
8650 fi
8651
8652
8653 test -n "$NAWK" && break
8654 done
8655
8656 else
8657 # If it succeeded, then it was overridden by the user. We will use it
8658 # for the tool.
8659
8660 # First remove it from the list of overridden variables, so we can test
8661 # for unknown variables in the end.
8662 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8663
8664 # Check if the provided tool contains a complete path.
8665 tool_specified="$NAWK"
8666 tool_basename="${tool_specified##*/}"
8667 if test "x$tool_basename" = "x$tool_specified"; then
8668 # A command without a complete path is provided, search $PATH.
8669 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8670 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8671 # Extract the first word of "$tool_basename", so it can be a program name with args.
8672 set dummy $tool_basename; ac_word=$2
8673 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8674 $as_echo_n "checking for $ac_word... " >&6; }
8675 if ${ac_cv_path_NAWK+:} false; then :
8676 $as_echo_n "(cached) " >&6
8677 else
8678 case $NAWK in
8679 [\\/]* | ?:[\\/]*)
8680 ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8681 ;;
8682 *)
8683 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8684 for as_dir in $PATH
8685 do
8686 IFS=$as_save_IFS
8687 test -z "$as_dir" && as_dir=.
8688 for ac_exec_ext in '' $ac_executable_extensions; do
8689 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8690 ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8691 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8692 break 2
8693 fi
8694 done
8695 done
8696 IFS=$as_save_IFS
8697
8698 ;;
8699 esac
8700 fi
8701 NAWK=$ac_cv_path_NAWK
8702 if test -n "$NAWK"; then
8703 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8704 $as_echo "$NAWK" >&6; }
8705 else
8706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8707 $as_echo "no" >&6; }
8708 fi
8709
8710
8711 if test "x$NAWK" = x; then
8712 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8713 fi
8714 else
8715 # Otherwise we believe it is a complete path. Use it as it is.
8716 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8717 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8719 $as_echo_n "checking for NAWK... " >&6; }
8720 if test ! -x "$tool_specified"; then
8721 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8722 $as_echo "not found" >&6; }
8723 as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8724 fi
8725 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8726 $as_echo "$tool_specified" >&6; }
8727 fi
8728 fi
8729 fi
8730
8731
8732
8733 if test "x$NAWK" = x; then
8734 as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8735 fi
8736
8737
8738
8739
8740
8741 # Publish this variable in the help.
8742
8743
8744 if test "x$PRINTF" = x; then
8745 # The variable is not set by user, try to locate tool using the code snippet
8746 for ac_prog in printf
8747 do
8748 # Extract the first word of "$ac_prog", so it can be a program name with args.
8749 set dummy $ac_prog; ac_word=$2
8750 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8751 $as_echo_n "checking for $ac_word... " >&6; }
8752 if ${ac_cv_path_PRINTF+:} false; then :
8753 $as_echo_n "(cached) " >&6
8754 else
8755 case $PRINTF in
8756 [\\/]* | ?:[\\/]*)
8757 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8758 ;;
8759 *)
8760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8761 for as_dir in $PATH
8762 do
8763 IFS=$as_save_IFS
8764 test -z "$as_dir" && as_dir=.
8765 for ac_exec_ext in '' $ac_executable_extensions; do
8766 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8767 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8768 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8769 break 2
8770 fi
8771 done
8772 done
8773 IFS=$as_save_IFS
8774
8775 ;;
8776 esac
8777 fi
8778 PRINTF=$ac_cv_path_PRINTF
8779 if test -n "$PRINTF"; then
8780 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8781 $as_echo "$PRINTF" >&6; }
8782 else
8783 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8784 $as_echo "no" >&6; }
8785 fi
8786
8787
8788 test -n "$PRINTF" && break
8789 done
8790
8791 else
8792 # The variable is set, but is it from the command line or the environment?
8793
8794 # Try to remove the string !PRINTF! from our list.
8795 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8796 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8797 # If it failed, the variable was not from the command line. Ignore it,
8798 # but warn the user (except for BASH, which is always set by the calling BASH).
8799 if test "xPRINTF" != xBASH; then
8800 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8801 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8802 fi
8803 # Try to locate tool using the code snippet
8804 for ac_prog in printf
8805 do
8806 # Extract the first word of "$ac_prog", so it can be a program name with args.
8807 set dummy $ac_prog; ac_word=$2
8808 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8809 $as_echo_n "checking for $ac_word... " >&6; }
8810 if ${ac_cv_path_PRINTF+:} false; then :
8811 $as_echo_n "(cached) " >&6
8812 else
8813 case $PRINTF in
8814 [\\/]* | ?:[\\/]*)
8815 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8816 ;;
8817 *)
8818 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8819 for as_dir in $PATH
8820 do
8821 IFS=$as_save_IFS
8822 test -z "$as_dir" && as_dir=.
8823 for ac_exec_ext in '' $ac_executable_extensions; do
8824 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8825 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8826 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8827 break 2
8828 fi
8829 done
8830 done
8831 IFS=$as_save_IFS
8832
8833 ;;
8834 esac
8835 fi
8836 PRINTF=$ac_cv_path_PRINTF
8837 if test -n "$PRINTF"; then
8838 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8839 $as_echo "$PRINTF" >&6; }
8840 else
8841 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8842 $as_echo "no" >&6; }
8843 fi
8844
8845
8846 test -n "$PRINTF" && break
8847 done
8848
8849 else
8850 # If it succeeded, then it was overridden by the user. We will use it
8851 # for the tool.
8852
8853 # First remove it from the list of overridden variables, so we can test
8854 # for unknown variables in the end.
8855 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8856
8857 # Check if the provided tool contains a complete path.
8858 tool_specified="$PRINTF"
8859 tool_basename="${tool_specified##*/}"
8860 if test "x$tool_basename" = "x$tool_specified"; then
8861 # A command without a complete path is provided, search $PATH.
8862 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8863 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8864 # Extract the first word of "$tool_basename", so it can be a program name with args.
8865 set dummy $tool_basename; ac_word=$2
8866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8867 $as_echo_n "checking for $ac_word... " >&6; }
8868 if ${ac_cv_path_PRINTF+:} false; then :
8869 $as_echo_n "(cached) " >&6
8870 else
8871 case $PRINTF in
8872 [\\/]* | ?:[\\/]*)
8873 ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8874 ;;
8875 *)
8876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8877 for as_dir in $PATH
8878 do
8879 IFS=$as_save_IFS
8880 test -z "$as_dir" && as_dir=.
8881 for ac_exec_ext in '' $ac_executable_extensions; do
8882 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8883 ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8884 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8885 break 2
8886 fi
8887 done
8888 done
8889 IFS=$as_save_IFS
8890
8891 ;;
8892 esac
8893 fi
8894 PRINTF=$ac_cv_path_PRINTF
8895 if test -n "$PRINTF"; then
8896 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8897 $as_echo "$PRINTF" >&6; }
8898 else
8899 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8900 $as_echo "no" >&6; }
8901 fi
8902
8903
8904 if test "x$PRINTF" = x; then
8905 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8906 fi
8907 else
8908 # Otherwise we believe it is a complete path. Use it as it is.
8909 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8910 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8912 $as_echo_n "checking for PRINTF... " >&6; }
8913 if test ! -x "$tool_specified"; then
8914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8915 $as_echo "not found" >&6; }
8916 as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8917 fi
8918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8919 $as_echo "$tool_specified" >&6; }
8920 fi
8921 fi
8922 fi
8923
8924
8925
8926 if test "x$PRINTF" = x; then
8927 as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8928 fi
8929
8930
8931
8932
8933
8934 # Publish this variable in the help.
8935
8936
8937 if test "x$RM" = x; then
8938 # The variable is not set by user, try to locate tool using the code snippet
8939 for ac_prog in rm
8940 do
8941 # Extract the first word of "$ac_prog", so it can be a program name with args.
8942 set dummy $ac_prog; ac_word=$2
8943 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8944 $as_echo_n "checking for $ac_word... " >&6; }
8945 if ${ac_cv_path_RM+:} false; then :
8946 $as_echo_n "(cached) " >&6
8947 else
8948 case $RM in
8949 [\\/]* | ?:[\\/]*)
8950 ac_cv_path_RM="$RM" # Let the user override the test with a path.
8951 ;;
8952 *)
8953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8954 for as_dir in $PATH
8955 do
8956 IFS=$as_save_IFS
8957 test -z "$as_dir" && as_dir=.
8958 for ac_exec_ext in '' $ac_executable_extensions; do
8959 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8960 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8961 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8962 break 2
8963 fi
8964 done
8965 done
8966 IFS=$as_save_IFS
8967
8968 ;;
8969 esac
8970 fi
8971 RM=$ac_cv_path_RM
8972 if test -n "$RM"; then
8973 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8974 $as_echo "$RM" >&6; }
8975 else
8976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8977 $as_echo "no" >&6; }
8978 fi
8979
8980
8981 test -n "$RM" && break
8982 done
8983
8984 else
8985 # The variable is set, but is it from the command line or the environment?
8986
8987 # Try to remove the string !RM! from our list.
8988 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8989 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8990 # If it failed, the variable was not from the command line. Ignore it,
8991 # but warn the user (except for BASH, which is always set by the calling BASH).
8992 if test "xRM" != xBASH; then
8993 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8994 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8995 fi
8996 # Try to locate tool using the code snippet
8997 for ac_prog in rm
8998 do
8999 # Extract the first word of "$ac_prog", so it can be a program name with args.
9000 set dummy $ac_prog; ac_word=$2
9001 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9002 $as_echo_n "checking for $ac_word... " >&6; }
9003 if ${ac_cv_path_RM+:} false; then :
9004 $as_echo_n "(cached) " >&6
9005 else
9006 case $RM in
9007 [\\/]* | ?:[\\/]*)
9008 ac_cv_path_RM="$RM" # Let the user override the test with a path.
9009 ;;
9010 *)
9011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9012 for as_dir in $PATH
9013 do
9014 IFS=$as_save_IFS
9015 test -z "$as_dir" && as_dir=.
9016 for ac_exec_ext in '' $ac_executable_extensions; do
9017 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9018 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9019 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9020 break 2
9021 fi
9022 done
9023 done
9024 IFS=$as_save_IFS
9025
9026 ;;
9027 esac
9028 fi
9029 RM=$ac_cv_path_RM
9030 if test -n "$RM"; then
9031 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9032 $as_echo "$RM" >&6; }
9033 else
9034 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9035 $as_echo "no" >&6; }
9036 fi
9037
9038
9039 test -n "$RM" && break
9040 done
9041
9042 else
9043 # If it succeeded, then it was overridden by the user. We will use it
9044 # for the tool.
9045
9046 # First remove it from the list of overridden variables, so we can test
9047 # for unknown variables in the end.
9048 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9049
9050 # Check if the provided tool contains a complete path.
9051 tool_specified="$RM"
9052 tool_basename="${tool_specified##*/}"
9053 if test "x$tool_basename" = "x$tool_specified"; then
9054 # A command without a complete path is provided, search $PATH.
9055 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9056 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9057 # Extract the first word of "$tool_basename", so it can be a program name with args.
9058 set dummy $tool_basename; ac_word=$2
9059 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9060 $as_echo_n "checking for $ac_word... " >&6; }
9061 if ${ac_cv_path_RM+:} false; then :
9062 $as_echo_n "(cached) " >&6
9063 else
9064 case $RM in
9065 [\\/]* | ?:[\\/]*)
9066 ac_cv_path_RM="$RM" # Let the user override the test with a path.
9067 ;;
9068 *)
9069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9070 for as_dir in $PATH
9071 do
9072 IFS=$as_save_IFS
9073 test -z "$as_dir" && as_dir=.
9074 for ac_exec_ext in '' $ac_executable_extensions; do
9075 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9076 ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9077 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9078 break 2
9079 fi
9080 done
9081 done
9082 IFS=$as_save_IFS
9083
9084 ;;
9085 esac
9086 fi
9087 RM=$ac_cv_path_RM
9088 if test -n "$RM"; then
9089 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9090 $as_echo "$RM" >&6; }
9091 else
9092 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9093 $as_echo "no" >&6; }
9094 fi
9095
9096
9097 if test "x$RM" = x; then
9098 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9099 fi
9100 else
9101 # Otherwise we believe it is a complete path. Use it as it is.
9102 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9103 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9105 $as_echo_n "checking for RM... " >&6; }
9106 if test ! -x "$tool_specified"; then
9107 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9108 $as_echo "not found" >&6; }
9109 as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9110 fi
9111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9112 $as_echo "$tool_specified" >&6; }
9113 fi
9114 fi
9115 fi
9116
9117
9118
9119 if test "x$RM" = x; then
9120 as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9121 fi
9122
9123
9124
9125
9126
9127 # Publish this variable in the help.
9128
9129
9130 if test "x$SH" = x; then
9131 # The variable is not set by user, try to locate tool using the code snippet
9132 for ac_prog in sh
9133 do
9134 # Extract the first word of "$ac_prog", so it can be a program name with args.
9135 set dummy $ac_prog; ac_word=$2
9136 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9137 $as_echo_n "checking for $ac_word... " >&6; }
9138 if ${ac_cv_path_SH+:} false; then :
9139 $as_echo_n "(cached) " >&6
9140 else
9141 case $SH in
9142 [\\/]* | ?:[\\/]*)
9143 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9144 ;;
9145 *)
9146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9147 for as_dir in $PATH
9148 do
9149 IFS=$as_save_IFS
9150 test -z "$as_dir" && as_dir=.
9151 for ac_exec_ext in '' $ac_executable_extensions; do
9152 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9153 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9154 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9155 break 2
9156 fi
9157 done
9158 done
9159 IFS=$as_save_IFS
9160
9161 ;;
9162 esac
9163 fi
9164 SH=$ac_cv_path_SH
9165 if test -n "$SH"; then
9166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9167 $as_echo "$SH" >&6; }
9168 else
9169 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9170 $as_echo "no" >&6; }
9171 fi
9172
9173
9174 test -n "$SH" && break
9175 done
9176
9177 else
9178 # The variable is set, but is it from the command line or the environment?
9179
9180 # Try to remove the string !SH! from our list.
9181 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9182 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9183 # If it failed, the variable was not from the command line. Ignore it,
9184 # but warn the user (except for BASH, which is always set by the calling BASH).
9185 if test "xSH" != xBASH; then
9186 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9187 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9188 fi
9189 # Try to locate tool using the code snippet
9190 for ac_prog in sh
9191 do
9192 # Extract the first word of "$ac_prog", so it can be a program name with args.
9193 set dummy $ac_prog; ac_word=$2
9194 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9195 $as_echo_n "checking for $ac_word... " >&6; }
9196 if ${ac_cv_path_SH+:} false; then :
9197 $as_echo_n "(cached) " >&6
9198 else
9199 case $SH in
9200 [\\/]* | ?:[\\/]*)
9201 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9202 ;;
9203 *)
9204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9205 for as_dir in $PATH
9206 do
9207 IFS=$as_save_IFS
9208 test -z "$as_dir" && as_dir=.
9209 for ac_exec_ext in '' $ac_executable_extensions; do
9210 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9211 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9212 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9213 break 2
9214 fi
9215 done
9216 done
9217 IFS=$as_save_IFS
9218
9219 ;;
9220 esac
9221 fi
9222 SH=$ac_cv_path_SH
9223 if test -n "$SH"; then
9224 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9225 $as_echo "$SH" >&6; }
9226 else
9227 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9228 $as_echo "no" >&6; }
9229 fi
9230
9231
9232 test -n "$SH" && break
9233 done
9234
9235 else
9236 # If it succeeded, then it was overridden by the user. We will use it
9237 # for the tool.
9238
9239 # First remove it from the list of overridden variables, so we can test
9240 # for unknown variables in the end.
9241 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9242
9243 # Check if the provided tool contains a complete path.
9244 tool_specified="$SH"
9245 tool_basename="${tool_specified##*/}"
9246 if test "x$tool_basename" = "x$tool_specified"; then
9247 # A command without a complete path is provided, search $PATH.
9248 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9249 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9250 # Extract the first word of "$tool_basename", so it can be a program name with args.
9251 set dummy $tool_basename; ac_word=$2
9252 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9253 $as_echo_n "checking for $ac_word... " >&6; }
9254 if ${ac_cv_path_SH+:} false; then :
9255 $as_echo_n "(cached) " >&6
9256 else
9257 case $SH in
9258 [\\/]* | ?:[\\/]*)
9259 ac_cv_path_SH="$SH" # Let the user override the test with a path.
9260 ;;
9261 *)
9262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9263 for as_dir in $PATH
9264 do
9265 IFS=$as_save_IFS
9266 test -z "$as_dir" && as_dir=.
9267 for ac_exec_ext in '' $ac_executable_extensions; do
9268 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9269 ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9270 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9271 break 2
9272 fi
9273 done
9274 done
9275 IFS=$as_save_IFS
9276
9277 ;;
9278 esac
9279 fi
9280 SH=$ac_cv_path_SH
9281 if test -n "$SH"; then
9282 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9283 $as_echo "$SH" >&6; }
9284 else
9285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9286 $as_echo "no" >&6; }
9287 fi
9288
9289
9290 if test "x$SH" = x; then
9291 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9292 fi
9293 else
9294 # Otherwise we believe it is a complete path. Use it as it is.
9295 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9296 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9298 $as_echo_n "checking for SH... " >&6; }
9299 if test ! -x "$tool_specified"; then
9300 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9301 $as_echo "not found" >&6; }
9302 as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9303 fi
9304 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9305 $as_echo "$tool_specified" >&6; }
9306 fi
9307 fi
9308 fi
9309
9310
9311
9312 if test "x$SH" = x; then
9313 as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9314 fi
9315
9316
9317
9318
9319
9320 # Publish this variable in the help.
9321
9322
9323 if test "x$SORT" = x; then
9324 # The variable is not set by user, try to locate tool using the code snippet
9325 for ac_prog in sort
9326 do
9327 # Extract the first word of "$ac_prog", so it can be a program name with args.
9328 set dummy $ac_prog; ac_word=$2
9329 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9330 $as_echo_n "checking for $ac_word... " >&6; }
9331 if ${ac_cv_path_SORT+:} false; then :
9332 $as_echo_n "(cached) " >&6
9333 else
9334 case $SORT in
9335 [\\/]* | ?:[\\/]*)
9336 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9337 ;;
9338 *)
9339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9340 for as_dir in $PATH
9341 do
9342 IFS=$as_save_IFS
9343 test -z "$as_dir" && as_dir=.
9344 for ac_exec_ext in '' $ac_executable_extensions; do
9345 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9346 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9347 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9348 break 2
9349 fi
9350 done
9351 done
9352 IFS=$as_save_IFS
9353
9354 ;;
9355 esac
9356 fi
9357 SORT=$ac_cv_path_SORT
9358 if test -n "$SORT"; then
9359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9360 $as_echo "$SORT" >&6; }
9361 else
9362 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9363 $as_echo "no" >&6; }
9364 fi
9365
9366
9367 test -n "$SORT" && break
9368 done
9369
9370 else
9371 # The variable is set, but is it from the command line or the environment?
9372
9373 # Try to remove the string !SORT! from our list.
9374 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9375 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9376 # If it failed, the variable was not from the command line. Ignore it,
9377 # but warn the user (except for BASH, which is always set by the calling BASH).
9378 if test "xSORT" != xBASH; then
9379 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9380 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9381 fi
9382 # Try to locate tool using the code snippet
9383 for ac_prog in sort
9384 do
9385 # Extract the first word of "$ac_prog", so it can be a program name with args.
9386 set dummy $ac_prog; ac_word=$2
9387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9388 $as_echo_n "checking for $ac_word... " >&6; }
9389 if ${ac_cv_path_SORT+:} false; then :
9390 $as_echo_n "(cached) " >&6
9391 else
9392 case $SORT in
9393 [\\/]* | ?:[\\/]*)
9394 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9395 ;;
9396 *)
9397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9398 for as_dir in $PATH
9399 do
9400 IFS=$as_save_IFS
9401 test -z "$as_dir" && as_dir=.
9402 for ac_exec_ext in '' $ac_executable_extensions; do
9403 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9404 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9405 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9406 break 2
9407 fi
9408 done
9409 done
9410 IFS=$as_save_IFS
9411
9412 ;;
9413 esac
9414 fi
9415 SORT=$ac_cv_path_SORT
9416 if test -n "$SORT"; then
9417 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9418 $as_echo "$SORT" >&6; }
9419 else
9420 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9421 $as_echo "no" >&6; }
9422 fi
9423
9424
9425 test -n "$SORT" && break
9426 done
9427
9428 else
9429 # If it succeeded, then it was overridden by the user. We will use it
9430 # for the tool.
9431
9432 # First remove it from the list of overridden variables, so we can test
9433 # for unknown variables in the end.
9434 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9435
9436 # Check if the provided tool contains a complete path.
9437 tool_specified="$SORT"
9438 tool_basename="${tool_specified##*/}"
9439 if test "x$tool_basename" = "x$tool_specified"; then
9440 # A command without a complete path is provided, search $PATH.
9441 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9442 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9443 # Extract the first word of "$tool_basename", so it can be a program name with args.
9444 set dummy $tool_basename; ac_word=$2
9445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9446 $as_echo_n "checking for $ac_word... " >&6; }
9447 if ${ac_cv_path_SORT+:} false; then :
9448 $as_echo_n "(cached) " >&6
9449 else
9450 case $SORT in
9451 [\\/]* | ?:[\\/]*)
9452 ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9453 ;;
9454 *)
9455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9456 for as_dir in $PATH
9457 do
9458 IFS=$as_save_IFS
9459 test -z "$as_dir" && as_dir=.
9460 for ac_exec_ext in '' $ac_executable_extensions; do
9461 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9462 ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9463 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9464 break 2
9465 fi
9466 done
9467 done
9468 IFS=$as_save_IFS
9469
9470 ;;
9471 esac
9472 fi
9473 SORT=$ac_cv_path_SORT
9474 if test -n "$SORT"; then
9475 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9476 $as_echo "$SORT" >&6; }
9477 else
9478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9479 $as_echo "no" >&6; }
9480 fi
9481
9482
9483 if test "x$SORT" = x; then
9484 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9485 fi
9486 else
9487 # Otherwise we believe it is a complete path. Use it as it is.
9488 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9489 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9491 $as_echo_n "checking for SORT... " >&6; }
9492 if test ! -x "$tool_specified"; then
9493 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9494 $as_echo "not found" >&6; }
9495 as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9496 fi
9497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9498 $as_echo "$tool_specified" >&6; }
9499 fi
9500 fi
9501 fi
9502
9503
9504
9505 if test "x$SORT" = x; then
9506 as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9507 fi
9508
9509
9510
9511
9512
9513 # Publish this variable in the help.
9514
9515
9516 if test "x$TAIL" = x; then
9517 # The variable is not set by user, try to locate tool using the code snippet
9518 for ac_prog in tail
9519 do
9520 # Extract the first word of "$ac_prog", so it can be a program name with args.
9521 set dummy $ac_prog; ac_word=$2
9522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9523 $as_echo_n "checking for $ac_word... " >&6; }
9524 if ${ac_cv_path_TAIL+:} false; then :
9525 $as_echo_n "(cached) " >&6
9526 else
9527 case $TAIL in
9528 [\\/]* | ?:[\\/]*)
9529 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9530 ;;
9531 *)
9532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9533 for as_dir in $PATH
9534 do
9535 IFS=$as_save_IFS
9536 test -z "$as_dir" && as_dir=.
9537 for ac_exec_ext in '' $ac_executable_extensions; do
9538 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9539 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9540 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9541 break 2
9542 fi
9543 done
9544 done
9545 IFS=$as_save_IFS
9546
9547 ;;
9548 esac
9549 fi
9550 TAIL=$ac_cv_path_TAIL
9551 if test -n "$TAIL"; then
9552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9553 $as_echo "$TAIL" >&6; }
9554 else
9555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9556 $as_echo "no" >&6; }
9557 fi
9558
9559
9560 test -n "$TAIL" && break
9561 done
9562
9563 else
9564 # The variable is set, but is it from the command line or the environment?
9565
9566 # Try to remove the string !TAIL! from our list.
9567 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9568 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9569 # If it failed, the variable was not from the command line. Ignore it,
9570 # but warn the user (except for BASH, which is always set by the calling BASH).
9571 if test "xTAIL" != xBASH; then
9572 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9573 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9574 fi
9575 # Try to locate tool using the code snippet
9576 for ac_prog in tail
9577 do
9578 # Extract the first word of "$ac_prog", so it can be a program name with args.
9579 set dummy $ac_prog; ac_word=$2
9580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9581 $as_echo_n "checking for $ac_word... " >&6; }
9582 if ${ac_cv_path_TAIL+:} false; then :
9583 $as_echo_n "(cached) " >&6
9584 else
9585 case $TAIL in
9586 [\\/]* | ?:[\\/]*)
9587 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9588 ;;
9589 *)
9590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9591 for as_dir in $PATH
9592 do
9593 IFS=$as_save_IFS
9594 test -z "$as_dir" && as_dir=.
9595 for ac_exec_ext in '' $ac_executable_extensions; do
9596 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9597 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9598 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9599 break 2
9600 fi
9601 done
9602 done
9603 IFS=$as_save_IFS
9604
9605 ;;
9606 esac
9607 fi
9608 TAIL=$ac_cv_path_TAIL
9609 if test -n "$TAIL"; then
9610 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9611 $as_echo "$TAIL" >&6; }
9612 else
9613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9614 $as_echo "no" >&6; }
9615 fi
9616
9617
9618 test -n "$TAIL" && break
9619 done
9620
9621 else
9622 # If it succeeded, then it was overridden by the user. We will use it
9623 # for the tool.
9624
9625 # First remove it from the list of overridden variables, so we can test
9626 # for unknown variables in the end.
9627 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9628
9629 # Check if the provided tool contains a complete path.
9630 tool_specified="$TAIL"
9631 tool_basename="${tool_specified##*/}"
9632 if test "x$tool_basename" = "x$tool_specified"; then
9633 # A command without a complete path is provided, search $PATH.
9634 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9635 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9636 # Extract the first word of "$tool_basename", so it can be a program name with args.
9637 set dummy $tool_basename; ac_word=$2
9638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9639 $as_echo_n "checking for $ac_word... " >&6; }
9640 if ${ac_cv_path_TAIL+:} false; then :
9641 $as_echo_n "(cached) " >&6
9642 else
9643 case $TAIL in
9644 [\\/]* | ?:[\\/]*)
9645 ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9646 ;;
9647 *)
9648 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9649 for as_dir in $PATH
9650 do
9651 IFS=$as_save_IFS
9652 test -z "$as_dir" && as_dir=.
9653 for ac_exec_ext in '' $ac_executable_extensions; do
9654 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9655 ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9656 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9657 break 2
9658 fi
9659 done
9660 done
9661 IFS=$as_save_IFS
9662
9663 ;;
9664 esac
9665 fi
9666 TAIL=$ac_cv_path_TAIL
9667 if test -n "$TAIL"; then
9668 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9669 $as_echo "$TAIL" >&6; }
9670 else
9671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9672 $as_echo "no" >&6; }
9673 fi
9674
9675
9676 if test "x$TAIL" = x; then
9677 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9678 fi
9679 else
9680 # Otherwise we believe it is a complete path. Use it as it is.
9681 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9682 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9683 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9684 $as_echo_n "checking for TAIL... " >&6; }
9685 if test ! -x "$tool_specified"; then
9686 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9687 $as_echo "not found" >&6; }
9688 as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9689 fi
9690 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9691 $as_echo "$tool_specified" >&6; }
9692 fi
9693 fi
9694 fi
9695
9696
9697
9698 if test "x$TAIL" = x; then
9699 as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9700 fi
9701
9702
9703
9704
9705
9706 # Publish this variable in the help.
9707
9708
9709 if test "x$TAR" = x; then
9710 # The variable is not set by user, try to locate tool using the code snippet
9711 for ac_prog in tar
9712 do
9713 # Extract the first word of "$ac_prog", so it can be a program name with args.
9714 set dummy $ac_prog; ac_word=$2
9715 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9716 $as_echo_n "checking for $ac_word... " >&6; }
9717 if ${ac_cv_path_TAR+:} false; then :
9718 $as_echo_n "(cached) " >&6
9719 else
9720 case $TAR in
9721 [\\/]* | ?:[\\/]*)
9722 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9723 ;;
9724 *)
9725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9726 for as_dir in $PATH
9727 do
9728 IFS=$as_save_IFS
9729 test -z "$as_dir" && as_dir=.
9730 for ac_exec_ext in '' $ac_executable_extensions; do
9731 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9732 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9733 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9734 break 2
9735 fi
9736 done
9737 done
9738 IFS=$as_save_IFS
9739
9740 ;;
9741 esac
9742 fi
9743 TAR=$ac_cv_path_TAR
9744 if test -n "$TAR"; then
9745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9746 $as_echo "$TAR" >&6; }
9747 else
9748 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9749 $as_echo "no" >&6; }
9750 fi
9751
9752
9753 test -n "$TAR" && break
9754 done
9755
9756 else
9757 # The variable is set, but is it from the command line or the environment?
9758
9759 # Try to remove the string !TAR! from our list.
9760 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9761 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9762 # If it failed, the variable was not from the command line. Ignore it,
9763 # but warn the user (except for BASH, which is always set by the calling BASH).
9764 if test "xTAR" != xBASH; then
9765 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9766 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9767 fi
9768 # Try to locate tool using the code snippet
9769 for ac_prog in tar
9770 do
9771 # Extract the first word of "$ac_prog", so it can be a program name with args.
9772 set dummy $ac_prog; ac_word=$2
9773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9774 $as_echo_n "checking for $ac_word... " >&6; }
9775 if ${ac_cv_path_TAR+:} false; then :
9776 $as_echo_n "(cached) " >&6
9777 else
9778 case $TAR in
9779 [\\/]* | ?:[\\/]*)
9780 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9781 ;;
9782 *)
9783 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9784 for as_dir in $PATH
9785 do
9786 IFS=$as_save_IFS
9787 test -z "$as_dir" && as_dir=.
9788 for ac_exec_ext in '' $ac_executable_extensions; do
9789 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9790 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9791 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9792 break 2
9793 fi
9794 done
9795 done
9796 IFS=$as_save_IFS
9797
9798 ;;
9799 esac
9800 fi
9801 TAR=$ac_cv_path_TAR
9802 if test -n "$TAR"; then
9803 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9804 $as_echo "$TAR" >&6; }
9805 else
9806 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9807 $as_echo "no" >&6; }
9808 fi
9809
9810
9811 test -n "$TAR" && break
9812 done
9813
9814 else
9815 # If it succeeded, then it was overridden by the user. We will use it
9816 # for the tool.
9817
9818 # First remove it from the list of overridden variables, so we can test
9819 # for unknown variables in the end.
9820 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9821
9822 # Check if the provided tool contains a complete path.
9823 tool_specified="$TAR"
9824 tool_basename="${tool_specified##*/}"
9825 if test "x$tool_basename" = "x$tool_specified"; then
9826 # A command without a complete path is provided, search $PATH.
9827 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9828 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9829 # Extract the first word of "$tool_basename", so it can be a program name with args.
9830 set dummy $tool_basename; ac_word=$2
9831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9832 $as_echo_n "checking for $ac_word... " >&6; }
9833 if ${ac_cv_path_TAR+:} false; then :
9834 $as_echo_n "(cached) " >&6
9835 else
9836 case $TAR in
9837 [\\/]* | ?:[\\/]*)
9838 ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9839 ;;
9840 *)
9841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9842 for as_dir in $PATH
9843 do
9844 IFS=$as_save_IFS
9845 test -z "$as_dir" && as_dir=.
9846 for ac_exec_ext in '' $ac_executable_extensions; do
9847 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9848 ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9849 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9850 break 2
9851 fi
9852 done
9853 done
9854 IFS=$as_save_IFS
9855
9856 ;;
9857 esac
9858 fi
9859 TAR=$ac_cv_path_TAR
9860 if test -n "$TAR"; then
9861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9862 $as_echo "$TAR" >&6; }
9863 else
9864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9865 $as_echo "no" >&6; }
9866 fi
9867
9868
9869 if test "x$TAR" = x; then
9870 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9871 fi
9872 else
9873 # Otherwise we believe it is a complete path. Use it as it is.
9874 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9875 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9877 $as_echo_n "checking for TAR... " >&6; }
9878 if test ! -x "$tool_specified"; then
9879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9880 $as_echo "not found" >&6; }
9881 as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9882 fi
9883 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9884 $as_echo "$tool_specified" >&6; }
9885 fi
9886 fi
9887 fi
9888
9889
9890
9891 if test "x$TAR" = x; then
9892 as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9893 fi
9894
9895
9896
9897
9898
9899 # Publish this variable in the help.
9900
9901
9902 if test "x$TEE" = x; then
9903 # The variable is not set by user, try to locate tool using the code snippet
9904 for ac_prog in tee
9905 do
9906 # Extract the first word of "$ac_prog", so it can be a program name with args.
9907 set dummy $ac_prog; ac_word=$2
9908 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9909 $as_echo_n "checking for $ac_word... " >&6; }
9910 if ${ac_cv_path_TEE+:} false; then :
9911 $as_echo_n "(cached) " >&6
9912 else
9913 case $TEE in
9914 [\\/]* | ?:[\\/]*)
9915 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9916 ;;
9917 *)
9918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9919 for as_dir in $PATH
9920 do
9921 IFS=$as_save_IFS
9922 test -z "$as_dir" && as_dir=.
9923 for ac_exec_ext in '' $ac_executable_extensions; do
9924 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9925 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9926 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9927 break 2
9928 fi
9929 done
9930 done
9931 IFS=$as_save_IFS
9932
9933 ;;
9934 esac
9935 fi
9936 TEE=$ac_cv_path_TEE
9937 if test -n "$TEE"; then
9938 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9939 $as_echo "$TEE" >&6; }
9940 else
9941 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9942 $as_echo "no" >&6; }
9943 fi
9944
9945
9946 test -n "$TEE" && break
9947 done
9948
9949 else
9950 # The variable is set, but is it from the command line or the environment?
9951
9952 # Try to remove the string !TEE! from our list.
9953 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9954 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9955 # If it failed, the variable was not from the command line. Ignore it,
9956 # but warn the user (except for BASH, which is always set by the calling BASH).
9957 if test "xTEE" != xBASH; then
9958 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9959 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9960 fi
9961 # Try to locate tool using the code snippet
9962 for ac_prog in tee
9963 do
9964 # Extract the first word of "$ac_prog", so it can be a program name with args.
9965 set dummy $ac_prog; ac_word=$2
9966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9967 $as_echo_n "checking for $ac_word... " >&6; }
9968 if ${ac_cv_path_TEE+:} false; then :
9969 $as_echo_n "(cached) " >&6
9970 else
9971 case $TEE in
9972 [\\/]* | ?:[\\/]*)
9973 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9974 ;;
9975 *)
9976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9977 for as_dir in $PATH
9978 do
9979 IFS=$as_save_IFS
9980 test -z "$as_dir" && as_dir=.
9981 for ac_exec_ext in '' $ac_executable_extensions; do
9982 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9983 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9984 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9985 break 2
9986 fi
9987 done
9988 done
9989 IFS=$as_save_IFS
9990
9991 ;;
9992 esac
9993 fi
9994 TEE=$ac_cv_path_TEE
9995 if test -n "$TEE"; then
9996 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9997 $as_echo "$TEE" >&6; }
9998 else
9999 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10000 $as_echo "no" >&6; }
10001 fi
10002
10003
10004 test -n "$TEE" && break
10005 done
10006
10007 else
10008 # If it succeeded, then it was overridden by the user. We will use it
10009 # for the tool.
10010
10011 # First remove it from the list of overridden variables, so we can test
10012 # for unknown variables in the end.
10013 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10014
10015 # Check if the provided tool contains a complete path.
10016 tool_specified="$TEE"
10017 tool_basename="${tool_specified##*/}"
10018 if test "x$tool_basename" = "x$tool_specified"; then
10019 # A command without a complete path is provided, search $PATH.
10020 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
10021 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
10022 # Extract the first word of "$tool_basename", so it can be a program name with args.
10023 set dummy $tool_basename; ac_word=$2
10024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10025 $as_echo_n "checking for $ac_word... " >&6; }
10026 if ${ac_cv_path_TEE+:} false; then :
10027 $as_echo_n "(cached) " >&6
10028 else
10029 case $TEE in
10030 [\\/]* | ?:[\\/]*)
10031 ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10032 ;;
10033 *)
10034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10035 for as_dir in $PATH
10036 do
10037 IFS=$as_save_IFS
10038 test -z "$as_dir" && as_dir=.
10039 for ac_exec_ext in '' $ac_executable_extensions; do
10040 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10041 ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10042 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10043 break 2
10044 fi
10045 done
10046 done
10047 IFS=$as_save_IFS
10048
10049 ;;
10050 esac
10051 fi
10052 TEE=$ac_cv_path_TEE
10053 if test -n "$TEE"; then
10054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10055 $as_echo "$TEE" >&6; }
10056 else
10057 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10058 $as_echo "no" >&6; }
10059 fi
10060
10061
10062 if test "x$TEE" = x; then
10063 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10064 fi
10065 else
10066 # Otherwise we believe it is a complete path. Use it as it is.
10067 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10068 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10070 $as_echo_n "checking for TEE... " >&6; }
10071 if test ! -x "$tool_specified"; then
10072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10073 $as_echo "not found" >&6; }
10074 as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10075 fi
10076 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10077 $as_echo "$tool_specified" >&6; }
10078 fi
10079 fi
10080 fi
10081
10082
10083
10084 if test "x$TEE" = x; then
10085 as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10086 fi
10087
10088
10089
10090
10091
10092 # Publish this variable in the help.
10093
10094
10095 if test "x$TOUCH" = x; then
10096 # The variable is not set by user, try to locate tool using the code snippet
10097 for ac_prog in touch
10098 do
10099 # Extract the first word of "$ac_prog", so it can be a program name with args.
10100 set dummy $ac_prog; ac_word=$2
10101 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10102 $as_echo_n "checking for $ac_word... " >&6; }
10103 if ${ac_cv_path_TOUCH+:} false; then :
10104 $as_echo_n "(cached) " >&6
10105 else
10106 case $TOUCH in
10107 [\\/]* | ?:[\\/]*)
10108 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10109 ;;
10110 *)
10111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10112 for as_dir in $PATH
10113 do
10114 IFS=$as_save_IFS
10115 test -z "$as_dir" && as_dir=.
10116 for ac_exec_ext in '' $ac_executable_extensions; do
10117 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10118 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10119 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10120 break 2
10121 fi
10122 done
10123 done
10124 IFS=$as_save_IFS
10125
10126 ;;
10127 esac
10128 fi
10129 TOUCH=$ac_cv_path_TOUCH
10130 if test -n "$TOUCH"; then
10131 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10132 $as_echo "$TOUCH" >&6; }
10133 else
10134 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10135 $as_echo "no" >&6; }
10136 fi
10137
10138
10139 test -n "$TOUCH" && break
10140 done
10141
10142 else
10143 # The variable is set, but is it from the command line or the environment?
10144
10145 # Try to remove the string !TOUCH! from our list.
10146 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10147 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10148 # If it failed, the variable was not from the command line. Ignore it,
10149 # but warn the user (except for BASH, which is always set by the calling BASH).
10150 if test "xTOUCH" != xBASH; then
10151 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10152 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10153 fi
10154 # Try to locate tool using the code snippet
10155 for ac_prog in touch
10156 do
10157 # Extract the first word of "$ac_prog", so it can be a program name with args.
10158 set dummy $ac_prog; ac_word=$2
10159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10160 $as_echo_n "checking for $ac_word... " >&6; }
10161 if ${ac_cv_path_TOUCH+:} false; then :
10162 $as_echo_n "(cached) " >&6
10163 else
10164 case $TOUCH in
10165 [\\/]* | ?:[\\/]*)
10166 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10167 ;;
10168 *)
10169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10170 for as_dir in $PATH
10171 do
10172 IFS=$as_save_IFS
10173 test -z "$as_dir" && as_dir=.
10174 for ac_exec_ext in '' $ac_executable_extensions; do
10175 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10176 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10177 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10178 break 2
10179 fi
10180 done
10181 done
10182 IFS=$as_save_IFS
10183
10184 ;;
10185 esac
10186 fi
10187 TOUCH=$ac_cv_path_TOUCH
10188 if test -n "$TOUCH"; then
10189 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10190 $as_echo "$TOUCH" >&6; }
10191 else
10192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10193 $as_echo "no" >&6; }
10194 fi
10195
10196
10197 test -n "$TOUCH" && break
10198 done
10199
10200 else
10201 # If it succeeded, then it was overridden by the user. We will use it
10202 # for the tool.
10203
10204 # First remove it from the list of overridden variables, so we can test
10205 # for unknown variables in the end.
10206 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10207
10208 # Check if the provided tool contains a complete path.
10209 tool_specified="$TOUCH"
10210 tool_basename="${tool_specified##*/}"
10211 if test "x$tool_basename" = "x$tool_specified"; then
10212 # A command without a complete path is provided, search $PATH.
10213 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10214 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10215 # Extract the first word of "$tool_basename", so it can be a program name with args.
10216 set dummy $tool_basename; ac_word=$2
10217 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10218 $as_echo_n "checking for $ac_word... " >&6; }
10219 if ${ac_cv_path_TOUCH+:} false; then :
10220 $as_echo_n "(cached) " >&6
10221 else
10222 case $TOUCH in
10223 [\\/]* | ?:[\\/]*)
10224 ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10225 ;;
10226 *)
10227 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10228 for as_dir in $PATH
10229 do
10230 IFS=$as_save_IFS
10231 test -z "$as_dir" && as_dir=.
10232 for ac_exec_ext in '' $ac_executable_extensions; do
10233 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10234 ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10235 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10236 break 2
10237 fi
10238 done
10239 done
10240 IFS=$as_save_IFS
10241
10242 ;;
10243 esac
10244 fi
10245 TOUCH=$ac_cv_path_TOUCH
10246 if test -n "$TOUCH"; then
10247 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10248 $as_echo "$TOUCH" >&6; }
10249 else
10250 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10251 $as_echo "no" >&6; }
10252 fi
10253
10254
10255 if test "x$TOUCH" = x; then
10256 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10257 fi
10258 else
10259 # Otherwise we believe it is a complete path. Use it as it is.
10260 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10261 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10262 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10263 $as_echo_n "checking for TOUCH... " >&6; }
10264 if test ! -x "$tool_specified"; then
10265 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10266 $as_echo "not found" >&6; }
10267 as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10268 fi
10269 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10270 $as_echo "$tool_specified" >&6; }
10271 fi
10272 fi
10273 fi
10274
10275
10276
10277 if test "x$TOUCH" = x; then
10278 as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10279 fi
10280
10281
10282
10283
10284
10285 # Publish this variable in the help.
10286
10287
10288 if test "x$TR" = x; then
10289 # The variable is not set by user, try to locate tool using the code snippet
10290 for ac_prog in tr
10291 do
10292 # Extract the first word of "$ac_prog", so it can be a program name with args.
10293 set dummy $ac_prog; ac_word=$2
10294 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10295 $as_echo_n "checking for $ac_word... " >&6; }
10296 if ${ac_cv_path_TR+:} false; then :
10297 $as_echo_n "(cached) " >&6
10298 else
10299 case $TR in
10300 [\\/]* | ?:[\\/]*)
10301 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10302 ;;
10303 *)
10304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10305 for as_dir in $PATH
10306 do
10307 IFS=$as_save_IFS
10308 test -z "$as_dir" && as_dir=.
10309 for ac_exec_ext in '' $ac_executable_extensions; do
10310 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10311 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10312 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10313 break 2
10314 fi
10315 done
10316 done
10317 IFS=$as_save_IFS
10318
10319 ;;
10320 esac
10321 fi
10322 TR=$ac_cv_path_TR
10323 if test -n "$TR"; then
10324 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10325 $as_echo "$TR" >&6; }
10326 else
10327 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10328 $as_echo "no" >&6; }
10329 fi
10330
10331
10332 test -n "$TR" && break
10333 done
10334
10335 else
10336 # The variable is set, but is it from the command line or the environment?
10337
10338 # Try to remove the string !TR! from our list.
10339 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10340 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10341 # If it failed, the variable was not from the command line. Ignore it,
10342 # but warn the user (except for BASH, which is always set by the calling BASH).
10343 if test "xTR" != xBASH; then
10344 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10345 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10346 fi
10347 # Try to locate tool using the code snippet
10348 for ac_prog in tr
10349 do
10350 # Extract the first word of "$ac_prog", so it can be a program name with args.
10351 set dummy $ac_prog; ac_word=$2
10352 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10353 $as_echo_n "checking for $ac_word... " >&6; }
10354 if ${ac_cv_path_TR+:} false; then :
10355 $as_echo_n "(cached) " >&6
10356 else
10357 case $TR in
10358 [\\/]* | ?:[\\/]*)
10359 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10360 ;;
10361 *)
10362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10363 for as_dir in $PATH
10364 do
10365 IFS=$as_save_IFS
10366 test -z "$as_dir" && as_dir=.
10367 for ac_exec_ext in '' $ac_executable_extensions; do
10368 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10369 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10370 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10371 break 2
10372 fi
10373 done
10374 done
10375 IFS=$as_save_IFS
10376
10377 ;;
10378 esac
10379 fi
10380 TR=$ac_cv_path_TR
10381 if test -n "$TR"; then
10382 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10383 $as_echo "$TR" >&6; }
10384 else
10385 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10386 $as_echo "no" >&6; }
10387 fi
10388
10389
10390 test -n "$TR" && break
10391 done
10392
10393 else
10394 # If it succeeded, then it was overridden by the user. We will use it
10395 # for the tool.
10396
10397 # First remove it from the list of overridden variables, so we can test
10398 # for unknown variables in the end.
10399 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10400
10401 # Check if the provided tool contains a complete path.
10402 tool_specified="$TR"
10403 tool_basename="${tool_specified##*/}"
10404 if test "x$tool_basename" = "x$tool_specified"; then
10405 # A command without a complete path is provided, search $PATH.
10406 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10407 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10408 # Extract the first word of "$tool_basename", so it can be a program name with args.
10409 set dummy $tool_basename; ac_word=$2
10410 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10411 $as_echo_n "checking for $ac_word... " >&6; }
10412 if ${ac_cv_path_TR+:} false; then :
10413 $as_echo_n "(cached) " >&6
10414 else
10415 case $TR in
10416 [\\/]* | ?:[\\/]*)
10417 ac_cv_path_TR="$TR" # Let the user override the test with a path.
10418 ;;
10419 *)
10420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10421 for as_dir in $PATH
10422 do
10423 IFS=$as_save_IFS
10424 test -z "$as_dir" && as_dir=.
10425 for ac_exec_ext in '' $ac_executable_extensions; do
10426 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10427 ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10428 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10429 break 2
10430 fi
10431 done
10432 done
10433 IFS=$as_save_IFS
10434
10435 ;;
10436 esac
10437 fi
10438 TR=$ac_cv_path_TR
10439 if test -n "$TR"; then
10440 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10441 $as_echo "$TR" >&6; }
10442 else
10443 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10444 $as_echo "no" >&6; }
10445 fi
10446
10447
10448 if test "x$TR" = x; then
10449 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10450 fi
10451 else
10452 # Otherwise we believe it is a complete path. Use it as it is.
10453 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10454 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10456 $as_echo_n "checking for TR... " >&6; }
10457 if test ! -x "$tool_specified"; then
10458 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10459 $as_echo "not found" >&6; }
10460 as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10461 fi
10462 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10463 $as_echo "$tool_specified" >&6; }
10464 fi
10465 fi
10466 fi
10467
10468
10469
10470 if test "x$TR" = x; then
10471 as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10472 fi
10473
10474
10475
10476
10477
10478 # Publish this variable in the help.
10479
10480
10481 if test "x$UNAME" = x; then
10482 # The variable is not set by user, try to locate tool using the code snippet
10483 for ac_prog in uname
10484 do
10485 # Extract the first word of "$ac_prog", so it can be a program name with args.
10486 set dummy $ac_prog; ac_word=$2
10487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10488 $as_echo_n "checking for $ac_word... " >&6; }
10489 if ${ac_cv_path_UNAME+:} false; then :
10490 $as_echo_n "(cached) " >&6
10491 else
10492 case $UNAME in
10493 [\\/]* | ?:[\\/]*)
10494 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10495 ;;
10496 *)
10497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10498 for as_dir in $PATH
10499 do
10500 IFS=$as_save_IFS
10501 test -z "$as_dir" && as_dir=.
10502 for ac_exec_ext in '' $ac_executable_extensions; do
10503 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10504 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10505 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10506 break 2
10507 fi
10508 done
10509 done
10510 IFS=$as_save_IFS
10511
10512 ;;
10513 esac
10514 fi
10515 UNAME=$ac_cv_path_UNAME
10516 if test -n "$UNAME"; then
10517 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10518 $as_echo "$UNAME" >&6; }
10519 else
10520 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10521 $as_echo "no" >&6; }
10522 fi
10523
10524
10525 test -n "$UNAME" && break
10526 done
10527
10528 else
10529 # The variable is set, but is it from the command line or the environment?
10530
10531 # Try to remove the string !UNAME! from our list.
10532 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10533 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10534 # If it failed, the variable was not from the command line. Ignore it,
10535 # but warn the user (except for BASH, which is always set by the calling BASH).
10536 if test "xUNAME" != xBASH; then
10537 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10538 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10539 fi
10540 # Try to locate tool using the code snippet
10541 for ac_prog in uname
10542 do
10543 # Extract the first word of "$ac_prog", so it can be a program name with args.
10544 set dummy $ac_prog; ac_word=$2
10545 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10546 $as_echo_n "checking for $ac_word... " >&6; }
10547 if ${ac_cv_path_UNAME+:} false; then :
10548 $as_echo_n "(cached) " >&6
10549 else
10550 case $UNAME in
10551 [\\/]* | ?:[\\/]*)
10552 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10553 ;;
10554 *)
10555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10556 for as_dir in $PATH
10557 do
10558 IFS=$as_save_IFS
10559 test -z "$as_dir" && as_dir=.
10560 for ac_exec_ext in '' $ac_executable_extensions; do
10561 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10562 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10563 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10564 break 2
10565 fi
10566 done
10567 done
10568 IFS=$as_save_IFS
10569
10570 ;;
10571 esac
10572 fi
10573 UNAME=$ac_cv_path_UNAME
10574 if test -n "$UNAME"; then
10575 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10576 $as_echo "$UNAME" >&6; }
10577 else
10578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10579 $as_echo "no" >&6; }
10580 fi
10581
10582
10583 test -n "$UNAME" && break
10584 done
10585
10586 else
10587 # If it succeeded, then it was overridden by the user. We will use it
10588 # for the tool.
10589
10590 # First remove it from the list of overridden variables, so we can test
10591 # for unknown variables in the end.
10592 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10593
10594 # Check if the provided tool contains a complete path.
10595 tool_specified="$UNAME"
10596 tool_basename="${tool_specified##*/}"
10597 if test "x$tool_basename" = "x$tool_specified"; then
10598 # A command without a complete path is provided, search $PATH.
10599 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10600 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10601 # Extract the first word of "$tool_basename", so it can be a program name with args.
10602 set dummy $tool_basename; ac_word=$2
10603 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10604 $as_echo_n "checking for $ac_word... " >&6; }
10605 if ${ac_cv_path_UNAME+:} false; then :
10606 $as_echo_n "(cached) " >&6
10607 else
10608 case $UNAME in
10609 [\\/]* | ?:[\\/]*)
10610 ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10611 ;;
10612 *)
10613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10614 for as_dir in $PATH
10615 do
10616 IFS=$as_save_IFS
10617 test -z "$as_dir" && as_dir=.
10618 for ac_exec_ext in '' $ac_executable_extensions; do
10619 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10620 ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10621 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10622 break 2
10623 fi
10624 done
10625 done
10626 IFS=$as_save_IFS
10627
10628 ;;
10629 esac
10630 fi
10631 UNAME=$ac_cv_path_UNAME
10632 if test -n "$UNAME"; then
10633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10634 $as_echo "$UNAME" >&6; }
10635 else
10636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10637 $as_echo "no" >&6; }
10638 fi
10639
10640
10641 if test "x$UNAME" = x; then
10642 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10643 fi
10644 else
10645 # Otherwise we believe it is a complete path. Use it as it is.
10646 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10647 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10649 $as_echo_n "checking for UNAME... " >&6; }
10650 if test ! -x "$tool_specified"; then
10651 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10652 $as_echo "not found" >&6; }
10653 as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10654 fi
10655 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10656 $as_echo "$tool_specified" >&6; }
10657 fi
10658 fi
10659 fi
10660
10661
10662
10663 if test "x$UNAME" = x; then
10664 as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10665 fi
10666
10667
10668
10669
10670
10671 # Publish this variable in the help.
10672
10673
10674 if test "x$UNIQ" = x; then
10675 # The variable is not set by user, try to locate tool using the code snippet
10676 for ac_prog in uniq
10677 do
10678 # Extract the first word of "$ac_prog", so it can be a program name with args.
10679 set dummy $ac_prog; ac_word=$2
10680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10681 $as_echo_n "checking for $ac_word... " >&6; }
10682 if ${ac_cv_path_UNIQ+:} false; then :
10683 $as_echo_n "(cached) " >&6
10684 else
10685 case $UNIQ in
10686 [\\/]* | ?:[\\/]*)
10687 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10688 ;;
10689 *)
10690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10691 for as_dir in $PATH
10692 do
10693 IFS=$as_save_IFS
10694 test -z "$as_dir" && as_dir=.
10695 for ac_exec_ext in '' $ac_executable_extensions; do
10696 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10697 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10698 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10699 break 2
10700 fi
10701 done
10702 done
10703 IFS=$as_save_IFS
10704
10705 ;;
10706 esac
10707 fi
10708 UNIQ=$ac_cv_path_UNIQ
10709 if test -n "$UNIQ"; then
10710 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10711 $as_echo "$UNIQ" >&6; }
10712 else
10713 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10714 $as_echo "no" >&6; }
10715 fi
10716
10717
10718 test -n "$UNIQ" && break
10719 done
10720
10721 else
10722 # The variable is set, but is it from the command line or the environment?
10723
10724 # Try to remove the string !UNIQ! from our list.
10725 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10726 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10727 # If it failed, the variable was not from the command line. Ignore it,
10728 # but warn the user (except for BASH, which is always set by the calling BASH).
10729 if test "xUNIQ" != xBASH; then
10730 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10731 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10732 fi
10733 # Try to locate tool using the code snippet
10734 for ac_prog in uniq
10735 do
10736 # Extract the first word of "$ac_prog", so it can be a program name with args.
10737 set dummy $ac_prog; ac_word=$2
10738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10739 $as_echo_n "checking for $ac_word... " >&6; }
10740 if ${ac_cv_path_UNIQ+:} false; then :
10741 $as_echo_n "(cached) " >&6
10742 else
10743 case $UNIQ in
10744 [\\/]* | ?:[\\/]*)
10745 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10746 ;;
10747 *)
10748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10749 for as_dir in $PATH
10750 do
10751 IFS=$as_save_IFS
10752 test -z "$as_dir" && as_dir=.
10753 for ac_exec_ext in '' $ac_executable_extensions; do
10754 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10755 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10756 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10757 break 2
10758 fi
10759 done
10760 done
10761 IFS=$as_save_IFS
10762
10763 ;;
10764 esac
10765 fi
10766 UNIQ=$ac_cv_path_UNIQ
10767 if test -n "$UNIQ"; then
10768 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10769 $as_echo "$UNIQ" >&6; }
10770 else
10771 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10772 $as_echo "no" >&6; }
10773 fi
10774
10775
10776 test -n "$UNIQ" && break
10777 done
10778
10779 else
10780 # If it succeeded, then it was overridden by the user. We will use it
10781 # for the tool.
10782
10783 # First remove it from the list of overridden variables, so we can test
10784 # for unknown variables in the end.
10785 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10786
10787 # Check if the provided tool contains a complete path.
10788 tool_specified="$UNIQ"
10789 tool_basename="${tool_specified##*/}"
10790 if test "x$tool_basename" = "x$tool_specified"; then
10791 # A command without a complete path is provided, search $PATH.
10792 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10793 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10794 # Extract the first word of "$tool_basename", so it can be a program name with args.
10795 set dummy $tool_basename; ac_word=$2
10796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10797 $as_echo_n "checking for $ac_word... " >&6; }
10798 if ${ac_cv_path_UNIQ+:} false; then :
10799 $as_echo_n "(cached) " >&6
10800 else
10801 case $UNIQ in
10802 [\\/]* | ?:[\\/]*)
10803 ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10804 ;;
10805 *)
10806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10807 for as_dir in $PATH
10808 do
10809 IFS=$as_save_IFS
10810 test -z "$as_dir" && as_dir=.
10811 for ac_exec_ext in '' $ac_executable_extensions; do
10812 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10813 ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10814 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10815 break 2
10816 fi
10817 done
10818 done
10819 IFS=$as_save_IFS
10820
10821 ;;
10822 esac
10823 fi
10824 UNIQ=$ac_cv_path_UNIQ
10825 if test -n "$UNIQ"; then
10826 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10827 $as_echo "$UNIQ" >&6; }
10828 else
10829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10830 $as_echo "no" >&6; }
10831 fi
10832
10833
10834 if test "x$UNIQ" = x; then
10835 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10836 fi
10837 else
10838 # Otherwise we believe it is a complete path. Use it as it is.
10839 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10840 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10842 $as_echo_n "checking for UNIQ... " >&6; }
10843 if test ! -x "$tool_specified"; then
10844 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10845 $as_echo "not found" >&6; }
10846 as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10847 fi
10848 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10849 $as_echo "$tool_specified" >&6; }
10850 fi
10851 fi
10852 fi
10853
10854
10855
10856 if test "x$UNIQ" = x; then
10857 as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10858 fi
10859
10860
10861
10862
10863
10864 # Publish this variable in the help.
10865
10866
10867 if test "x$WC" = x; then
10868 # The variable is not set by user, try to locate tool using the code snippet
10869 for ac_prog in wc
10870 do
10871 # Extract the first word of "$ac_prog", so it can be a program name with args.
10872 set dummy $ac_prog; ac_word=$2
10873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10874 $as_echo_n "checking for $ac_word... " >&6; }
10875 if ${ac_cv_path_WC+:} false; then :
10876 $as_echo_n "(cached) " >&6
10877 else
10878 case $WC in
10879 [\\/]* | ?:[\\/]*)
10880 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10881 ;;
10882 *)
10883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10884 for as_dir in $PATH
10885 do
10886 IFS=$as_save_IFS
10887 test -z "$as_dir" && as_dir=.
10888 for ac_exec_ext in '' $ac_executable_extensions; do
10889 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10890 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10891 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10892 break 2
10893 fi
10894 done
10895 done
10896 IFS=$as_save_IFS
10897
10898 ;;
10899 esac
10900 fi
10901 WC=$ac_cv_path_WC
10902 if test -n "$WC"; then
10903 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10904 $as_echo "$WC" >&6; }
10905 else
10906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10907 $as_echo "no" >&6; }
10908 fi
10909
10910
10911 test -n "$WC" && break
10912 done
10913
10914 else
10915 # The variable is set, but is it from the command line or the environment?
10916
10917 # Try to remove the string !WC! from our list.
10918 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10919 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10920 # If it failed, the variable was not from the command line. Ignore it,
10921 # but warn the user (except for BASH, which is always set by the calling BASH).
10922 if test "xWC" != xBASH; then
10923 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10924 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10925 fi
10926 # Try to locate tool using the code snippet
10927 for ac_prog in wc
10928 do
10929 # Extract the first word of "$ac_prog", so it can be a program name with args.
10930 set dummy $ac_prog; ac_word=$2
10931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10932 $as_echo_n "checking for $ac_word... " >&6; }
10933 if ${ac_cv_path_WC+:} false; then :
10934 $as_echo_n "(cached) " >&6
10935 else
10936 case $WC in
10937 [\\/]* | ?:[\\/]*)
10938 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10939 ;;
10940 *)
10941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10942 for as_dir in $PATH
10943 do
10944 IFS=$as_save_IFS
10945 test -z "$as_dir" && as_dir=.
10946 for ac_exec_ext in '' $ac_executable_extensions; do
10947 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10948 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10949 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10950 break 2
10951 fi
10952 done
10953 done
10954 IFS=$as_save_IFS
10955
10956 ;;
10957 esac
10958 fi
10959 WC=$ac_cv_path_WC
10960 if test -n "$WC"; then
10961 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10962 $as_echo "$WC" >&6; }
10963 else
10964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10965 $as_echo "no" >&6; }
10966 fi
10967
10968
10969 test -n "$WC" && break
10970 done
10971
10972 else
10973 # If it succeeded, then it was overridden by the user. We will use it
10974 # for the tool.
10975
10976 # First remove it from the list of overridden variables, so we can test
10977 # for unknown variables in the end.
10978 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10979
10980 # Check if the provided tool contains a complete path.
10981 tool_specified="$WC"
10982 tool_basename="${tool_specified##*/}"
10983 if test "x$tool_basename" = "x$tool_specified"; then
10984 # A command without a complete path is provided, search $PATH.
10985 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10986 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10987 # Extract the first word of "$tool_basename", so it can be a program name with args.
10988 set dummy $tool_basename; ac_word=$2
10989 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10990 $as_echo_n "checking for $ac_word... " >&6; }
10991 if ${ac_cv_path_WC+:} false; then :
10992 $as_echo_n "(cached) " >&6
10993 else
10994 case $WC in
10995 [\\/]* | ?:[\\/]*)
10996 ac_cv_path_WC="$WC" # Let the user override the test with a path.
10997 ;;
10998 *)
10999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11000 for as_dir in $PATH
11001 do
11002 IFS=$as_save_IFS
11003 test -z "$as_dir" && as_dir=.
11004 for ac_exec_ext in '' $ac_executable_extensions; do
11005 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11006 ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11007 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11008 break 2
11009 fi
11010 done
11011 done
11012 IFS=$as_save_IFS
11013
11014 ;;
11015 esac
11016 fi
11017 WC=$ac_cv_path_WC
11018 if test -n "$WC"; then
11019 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11020 $as_echo "$WC" >&6; }
11021 else
11022 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11023 $as_echo "no" >&6; }
11024 fi
11025
11026
11027 if test "x$WC" = x; then
11028 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11029 fi
11030 else
11031 # Otherwise we believe it is a complete path. Use it as it is.
11032 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
11033 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
11034 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11035 $as_echo_n "checking for WC... " >&6; }
11036 if test ! -x "$tool_specified"; then
11037 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11038 $as_echo "not found" >&6; }
11039 as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
11040 fi
11041 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11042 $as_echo "$tool_specified" >&6; }
11043 fi
11044 fi
11045 fi
11046
11047
11048
11049 if test "x$WC" = x; then
11050 as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
11051 fi
11052
11053
11054
11055
11056
11057 # Publish this variable in the help.
11058
11059
11060 if test "x$WHICH" = x; then
11061 # The variable is not set by user, try to locate tool using the code snippet
11062 for ac_prog in which
11063 do
11064 # Extract the first word of "$ac_prog", so it can be a program name with args.
11065 set dummy $ac_prog; ac_word=$2
11066 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11067 $as_echo_n "checking for $ac_word... " >&6; }
11068 if ${ac_cv_path_WHICH+:} false; then :
11069 $as_echo_n "(cached) " >&6
11070 else
11071 case $WHICH in
11072 [\\/]* | ?:[\\/]*)
11073 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11074 ;;
11075 *)
11076 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11077 for as_dir in $PATH
11078 do
11079 IFS=$as_save_IFS
11080 test -z "$as_dir" && as_dir=.
11081 for ac_exec_ext in '' $ac_executable_extensions; do
11082 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11083 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11084 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11085 break 2
11086 fi
11087 done
11088 done
11089 IFS=$as_save_IFS
11090
11091 ;;
11092 esac
11093 fi
11094 WHICH=$ac_cv_path_WHICH
11095 if test -n "$WHICH"; then
11096 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11097 $as_echo "$WHICH" >&6; }
11098 else
11099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11100 $as_echo "no" >&6; }
11101 fi
11102
11103
11104 test -n "$WHICH" && break
11105 done
11106
11107 else
11108 # The variable is set, but is it from the command line or the environment?
11109
11110 # Try to remove the string !WHICH! from our list.
11111 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11112 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11113 # If it failed, the variable was not from the command line. Ignore it,
11114 # but warn the user (except for BASH, which is always set by the calling BASH).
11115 if test "xWHICH" != xBASH; then
11116 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11117 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11118 fi
11119 # Try to locate tool using the code snippet
11120 for ac_prog in which
11121 do
11122 # Extract the first word of "$ac_prog", so it can be a program name with args.
11123 set dummy $ac_prog; ac_word=$2
11124 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11125 $as_echo_n "checking for $ac_word... " >&6; }
11126 if ${ac_cv_path_WHICH+:} false; then :
11127 $as_echo_n "(cached) " >&6
11128 else
11129 case $WHICH in
11130 [\\/]* | ?:[\\/]*)
11131 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11132 ;;
11133 *)
11134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11135 for as_dir in $PATH
11136 do
11137 IFS=$as_save_IFS
11138 test -z "$as_dir" && as_dir=.
11139 for ac_exec_ext in '' $ac_executable_extensions; do
11140 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11141 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11142 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11143 break 2
11144 fi
11145 done
11146 done
11147 IFS=$as_save_IFS
11148
11149 ;;
11150 esac
11151 fi
11152 WHICH=$ac_cv_path_WHICH
11153 if test -n "$WHICH"; then
11154 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11155 $as_echo "$WHICH" >&6; }
11156 else
11157 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11158 $as_echo "no" >&6; }
11159 fi
11160
11161
11162 test -n "$WHICH" && break
11163 done
11164
11165 else
11166 # If it succeeded, then it was overridden by the user. We will use it
11167 # for the tool.
11168
11169 # First remove it from the list of overridden variables, so we can test
11170 # for unknown variables in the end.
11171 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11172
11173 # Check if the provided tool contains a complete path.
11174 tool_specified="$WHICH"
11175 tool_basename="${tool_specified##*/}"
11176 if test "x$tool_basename" = "x$tool_specified"; then
11177 # A command without a complete path is provided, search $PATH.
11178 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11179 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11180 # Extract the first word of "$tool_basename", so it can be a program name with args.
11181 set dummy $tool_basename; ac_word=$2
11182 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11183 $as_echo_n "checking for $ac_word... " >&6; }
11184 if ${ac_cv_path_WHICH+:} false; then :
11185 $as_echo_n "(cached) " >&6
11186 else
11187 case $WHICH in
11188 [\\/]* | ?:[\\/]*)
11189 ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11190 ;;
11191 *)
11192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11193 for as_dir in $PATH
11194 do
11195 IFS=$as_save_IFS
11196 test -z "$as_dir" && as_dir=.
11197 for ac_exec_ext in '' $ac_executable_extensions; do
11198 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11199 ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11200 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11201 break 2
11202 fi
11203 done
11204 done
11205 IFS=$as_save_IFS
11206
11207 ;;
11208 esac
11209 fi
11210 WHICH=$ac_cv_path_WHICH
11211 if test -n "$WHICH"; then
11212 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11213 $as_echo "$WHICH" >&6; }
11214 else
11215 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11216 $as_echo "no" >&6; }
11217 fi
11218
11219
11220 if test "x$WHICH" = x; then
11221 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11222 fi
11223 else
11224 # Otherwise we believe it is a complete path. Use it as it is.
11225 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11226 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11228 $as_echo_n "checking for WHICH... " >&6; }
11229 if test ! -x "$tool_specified"; then
11230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11231 $as_echo "not found" >&6; }
11232 as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11233 fi
11234 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11235 $as_echo "$tool_specified" >&6; }
11236 fi
11237 fi
11238 fi
11239
11240
11241
11242 if test "x$WHICH" = x; then
11243 as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11244 fi
11245
11246
11247
11248
11249
11250 # Publish this variable in the help.
11251
11252
11253 if test "x$XARGS" = x; then
11254 # The variable is not set by user, try to locate tool using the code snippet
11255 for ac_prog in xargs
11256 do
11257 # Extract the first word of "$ac_prog", so it can be a program name with args.
11258 set dummy $ac_prog; ac_word=$2
11259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11260 $as_echo_n "checking for $ac_word... " >&6; }
11261 if ${ac_cv_path_XARGS+:} false; then :
11262 $as_echo_n "(cached) " >&6
11263 else
11264 case $XARGS in
11265 [\\/]* | ?:[\\/]*)
11266 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11267 ;;
11268 *)
11269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11270 for as_dir in $PATH
11271 do
11272 IFS=$as_save_IFS
11273 test -z "$as_dir" && as_dir=.
11274 for ac_exec_ext in '' $ac_executable_extensions; do
11275 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11276 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11277 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11278 break 2
11279 fi
11280 done
11281 done
11282 IFS=$as_save_IFS
11283
11284 ;;
11285 esac
11286 fi
11287 XARGS=$ac_cv_path_XARGS
11288 if test -n "$XARGS"; then
11289 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11290 $as_echo "$XARGS" >&6; }
11291 else
11292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11293 $as_echo "no" >&6; }
11294 fi
11295
11296
11297 test -n "$XARGS" && break
11298 done
11299
11300 else
11301 # The variable is set, but is it from the command line or the environment?
11302
11303 # Try to remove the string !XARGS! from our list.
11304 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11305 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11306 # If it failed, the variable was not from the command line. Ignore it,
11307 # but warn the user (except for BASH, which is always set by the calling BASH).
11308 if test "xXARGS" != xBASH; then
11309 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11310 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11311 fi
11312 # Try to locate tool using the code snippet
11313 for ac_prog in xargs
11314 do
11315 # Extract the first word of "$ac_prog", so it can be a program name with args.
11316 set dummy $ac_prog; ac_word=$2
11317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11318 $as_echo_n "checking for $ac_word... " >&6; }
11319 if ${ac_cv_path_XARGS+:} false; then :
11320 $as_echo_n "(cached) " >&6
11321 else
11322 case $XARGS in
11323 [\\/]* | ?:[\\/]*)
11324 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11325 ;;
11326 *)
11327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11328 for as_dir in $PATH
11329 do
11330 IFS=$as_save_IFS
11331 test -z "$as_dir" && as_dir=.
11332 for ac_exec_ext in '' $ac_executable_extensions; do
11333 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11334 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11335 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11336 break 2
11337 fi
11338 done
11339 done
11340 IFS=$as_save_IFS
11341
11342 ;;
11343 esac
11344 fi
11345 XARGS=$ac_cv_path_XARGS
11346 if test -n "$XARGS"; then
11347 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11348 $as_echo "$XARGS" >&6; }
11349 else
11350 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11351 $as_echo "no" >&6; }
11352 fi
11353
11354
11355 test -n "$XARGS" && break
11356 done
11357
11358 else
11359 # If it succeeded, then it was overridden by the user. We will use it
11360 # for the tool.
11361
11362 # First remove it from the list of overridden variables, so we can test
11363 # for unknown variables in the end.
11364 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11365
11366 # Check if the provided tool contains a complete path.
11367 tool_specified="$XARGS"
11368 tool_basename="${tool_specified##*/}"
11369 if test "x$tool_basename" = "x$tool_specified"; then
11370 # A command without a complete path is provided, search $PATH.
11371 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11372 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11373 # Extract the first word of "$tool_basename", so it can be a program name with args.
11374 set dummy $tool_basename; ac_word=$2
11375 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11376 $as_echo_n "checking for $ac_word... " >&6; }
11377 if ${ac_cv_path_XARGS+:} false; then :
11378 $as_echo_n "(cached) " >&6
11379 else
11380 case $XARGS in
11381 [\\/]* | ?:[\\/]*)
11382 ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11383 ;;
11384 *)
11385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11386 for as_dir in $PATH
11387 do
11388 IFS=$as_save_IFS
11389 test -z "$as_dir" && as_dir=.
11390 for ac_exec_ext in '' $ac_executable_extensions; do
11391 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11392 ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11393 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11394 break 2
11395 fi
11396 done
11397 done
11398 IFS=$as_save_IFS
11399
11400 ;;
11401 esac
11402 fi
11403 XARGS=$ac_cv_path_XARGS
11404 if test -n "$XARGS"; then
11405 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11406 $as_echo "$XARGS" >&6; }
11407 else
11408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11409 $as_echo "no" >&6; }
11410 fi
11411
11412
11413 if test "x$XARGS" = x; then
11414 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11415 fi
11416 else
11417 # Otherwise we believe it is a complete path. Use it as it is.
11418 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11419 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11421 $as_echo_n "checking for XARGS... " >&6; }
11422 if test ! -x "$tool_specified"; then
11423 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11424 $as_echo "not found" >&6; }
11425 as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11426 fi
11427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11428 $as_echo "$tool_specified" >&6; }
11429 fi
11430 fi
11431 fi
11432
11433
11434
11435 if test "x$XARGS" = x; then
11436 as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11437 fi
11438
11439
11440
11441 # Then required tools that require some special treatment.
11442
11443
11444 # Publish this variable in the help.
11445
11446
11447 if test "x$AWK" = x; then
11448 # The variable is not set by user, try to locate tool using the code snippet
11449 for ac_prog in gawk mawk nawk awk
11450 do
11451 # Extract the first word of "$ac_prog", so it can be a program name with args.
11452 set dummy $ac_prog; ac_word=$2
11453 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11454 $as_echo_n "checking for $ac_word... " >&6; }
11455 if ${ac_cv_prog_AWK+:} false; then :
11456 $as_echo_n "(cached) " >&6
11457 else
11458 if test -n "$AWK"; then
11459 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11460 else
11461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11462 for as_dir in $PATH
11463 do
11464 IFS=$as_save_IFS
11465 test -z "$as_dir" && as_dir=.
11466 for ac_exec_ext in '' $ac_executable_extensions; do
11467 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11468 ac_cv_prog_AWK="$ac_prog"
11469 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11470 break 2
11471 fi
11472 done
11473 done
11474 IFS=$as_save_IFS
11475
11476 fi
11477 fi
11478 AWK=$ac_cv_prog_AWK
11479 if test -n "$AWK"; then
11480 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11481 $as_echo "$AWK" >&6; }
11482 else
11483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11484 $as_echo "no" >&6; }
11485 fi
11486
11487
11488 test -n "$AWK" && break
11489 done
11490
11491 else
11492 # The variable is set, but is it from the command line or the environment?
11493
11494 # Try to remove the string !AWK! from our list.
11495 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11496 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11497 # If it failed, the variable was not from the command line. Ignore it,
11498 # but warn the user (except for BASH, which is always set by the calling BASH).
11499 if test "xAWK" != xBASH; then
11500 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11501 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11502 fi
11503 # Try to locate tool using the code snippet
11504 for ac_prog in gawk mawk nawk awk
11505 do
11506 # Extract the first word of "$ac_prog", so it can be a program name with args.
11507 set dummy $ac_prog; ac_word=$2
11508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11509 $as_echo_n "checking for $ac_word... " >&6; }
11510 if ${ac_cv_prog_AWK+:} false; then :
11511 $as_echo_n "(cached) " >&6
11512 else
11513 if test -n "$AWK"; then
11514 ac_cv_prog_AWK="$AWK" # Let the user override the test.
11515 else
11516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11517 for as_dir in $PATH
11518 do
11519 IFS=$as_save_IFS
11520 test -z "$as_dir" && as_dir=.
11521 for ac_exec_ext in '' $ac_executable_extensions; do
11522 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11523 ac_cv_prog_AWK="$ac_prog"
11524 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11525 break 2
11526 fi
11527 done
11528 done
11529 IFS=$as_save_IFS
11530
11531 fi
11532 fi
11533 AWK=$ac_cv_prog_AWK
11534 if test -n "$AWK"; then
11535 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11536 $as_echo "$AWK" >&6; }
11537 else
11538 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11539 $as_echo "no" >&6; }
11540 fi
11541
11542
11543 test -n "$AWK" && break
11544 done
11545
11546 else
11547 # If it succeeded, then it was overridden by the user. We will use it
11548 # for the tool.
11549
11550 # First remove it from the list of overridden variables, so we can test
11551 # for unknown variables in the end.
11552 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11553
11554 # Check if the provided tool contains a complete path.
11555 tool_specified="$AWK"
11556 tool_basename="${tool_specified##*/}"
11557 if test "x$tool_basename" = "x$tool_specified"; then
11558 # A command without a complete path is provided, search $PATH.
11559 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11560 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11561 # Extract the first word of "$tool_basename", so it can be a program name with args.
11562 set dummy $tool_basename; ac_word=$2
11563 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11564 $as_echo_n "checking for $ac_word... " >&6; }
11565 if ${ac_cv_path_AWK+:} false; then :
11566 $as_echo_n "(cached) " >&6
11567 else
11568 case $AWK in
11569 [\\/]* | ?:[\\/]*)
11570 ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11571 ;;
11572 *)
11573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11574 for as_dir in $PATH
11575 do
11576 IFS=$as_save_IFS
11577 test -z "$as_dir" && as_dir=.
11578 for ac_exec_ext in '' $ac_executable_extensions; do
11579 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11580 ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11581 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11582 break 2
11583 fi
11584 done
11585 done
11586 IFS=$as_save_IFS
11587
11588 ;;
11589 esac
11590 fi
11591 AWK=$ac_cv_path_AWK
11592 if test -n "$AWK"; then
11593 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11594 $as_echo "$AWK" >&6; }
11595 else
11596 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11597 $as_echo "no" >&6; }
11598 fi
11599
11600
11601 if test "x$AWK" = x; then
11602 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11603 fi
11604 else
11605 # Otherwise we believe it is a complete path. Use it as it is.
11606 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11607 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11609 $as_echo_n "checking for AWK... " >&6; }
11610 if test ! -x "$tool_specified"; then
11611 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11612 $as_echo "not found" >&6; }
11613 as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11614 fi
11615 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11616 $as_echo "$tool_specified" >&6; }
11617 fi
11618 fi
11619 fi
11620
11621
11622 if test "x$AWK" = x; then
11623 as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11624 fi
11625
11626
11627
11628
11629 # Publish this variable in the help.
11630
11631
11632 if test "x$GREP" = x; then
11633 # The variable is not set by user, try to locate tool using the code snippet
11634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11635 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11636 if ${ac_cv_path_GREP+:} false; then :
11637 $as_echo_n "(cached) " >&6
11638 else
11639 if test -z "$GREP"; then
11640 ac_path_GREP_found=false
11641 # Loop through the user's path and test for each of PROGNAME-LIST
11642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11643 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11644 do
11645 IFS=$as_save_IFS
11646 test -z "$as_dir" && as_dir=.
11647 for ac_prog in grep ggrep; do
11648 for ac_exec_ext in '' $ac_executable_extensions; do
11649 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11650 as_fn_executable_p "$ac_path_GREP" || continue
11651 # Check for GNU ac_path_GREP and select it if it is found.
11652 # Check for GNU $ac_path_GREP
11653 case `"$ac_path_GREP" --version 2>&1` in
11654 *GNU*)
11655 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11656 *)
11657 ac_count=0
11658 $as_echo_n 0123456789 >"conftest.in"
11659 while :
11660 do
11661 cat "conftest.in" "conftest.in" >"conftest.tmp"
11662 mv "conftest.tmp" "conftest.in"
11663 cp "conftest.in" "conftest.nl"
11664 $as_echo 'GREP' >> "conftest.nl"
11665 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11666 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11667 as_fn_arith $ac_count + 1 && ac_count=$as_val
11668 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11669 # Best one so far, save it but keep looking for a better one
11670 ac_cv_path_GREP="$ac_path_GREP"
11671 ac_path_GREP_max=$ac_count
11672 fi
11673 # 10*(2^10) chars as input seems more than enough
11674 test $ac_count -gt 10 && break
11675 done
11676 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11677 esac
11678
11679 $ac_path_GREP_found && break 3
11680 done
11681 done
11682 done
11683 IFS=$as_save_IFS
11684 if test -z "$ac_cv_path_GREP"; then
11685 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11686 fi
11687 else
11688 ac_cv_path_GREP=$GREP
11689 fi
11690
11691 fi
11692 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11693 $as_echo "$ac_cv_path_GREP" >&6; }
11694 GREP="$ac_cv_path_GREP"
11695
11696
11697 else
11698 # The variable is set, but is it from the command line or the environment?
11699
11700 # Try to remove the string !GREP! from our list.
11701 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11702 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11703 # If it failed, the variable was not from the command line. Ignore it,
11704 # but warn the user (except for BASH, which is always set by the calling BASH).
11705 if test "xGREP" != xBASH; then
11706 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11707 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11708 fi
11709 # Try to locate tool using the code snippet
11710 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11711 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11712 if ${ac_cv_path_GREP+:} false; then :
11713 $as_echo_n "(cached) " >&6
11714 else
11715 if test -z "$GREP"; then
11716 ac_path_GREP_found=false
11717 # Loop through the user's path and test for each of PROGNAME-LIST
11718 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11719 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11720 do
11721 IFS=$as_save_IFS
11722 test -z "$as_dir" && as_dir=.
11723 for ac_prog in grep ggrep; do
11724 for ac_exec_ext in '' $ac_executable_extensions; do
11725 ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11726 as_fn_executable_p "$ac_path_GREP" || continue
11727 # Check for GNU ac_path_GREP and select it if it is found.
11728 # Check for GNU $ac_path_GREP
11729 case `"$ac_path_GREP" --version 2>&1` in
11730 *GNU*)
11731 ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11732 *)
11733 ac_count=0
11734 $as_echo_n 0123456789 >"conftest.in"
11735 while :
11736 do
11737 cat "conftest.in" "conftest.in" >"conftest.tmp"
11738 mv "conftest.tmp" "conftest.in"
11739 cp "conftest.in" "conftest.nl"
11740 $as_echo 'GREP' >> "conftest.nl"
11741 "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11742 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11743 as_fn_arith $ac_count + 1 && ac_count=$as_val
11744 if test $ac_count -gt ${ac_path_GREP_max-0}; then
11745 # Best one so far, save it but keep looking for a better one
11746 ac_cv_path_GREP="$ac_path_GREP"
11747 ac_path_GREP_max=$ac_count
11748 fi
11749 # 10*(2^10) chars as input seems more than enough
11750 test $ac_count -gt 10 && break
11751 done
11752 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11753 esac
11754
11755 $ac_path_GREP_found && break 3
11756 done
11757 done
11758 done
11759 IFS=$as_save_IFS
11760 if test -z "$ac_cv_path_GREP"; then
11761 as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11762 fi
11763 else
11764 ac_cv_path_GREP=$GREP
11765 fi
11766
11767 fi
11768 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11769 $as_echo "$ac_cv_path_GREP" >&6; }
11770 GREP="$ac_cv_path_GREP"
11771
11772
11773 else
11774 # If it succeeded, then it was overridden by the user. We will use it
11775 # for the tool.
11776
11777 # First remove it from the list of overridden variables, so we can test
11778 # for unknown variables in the end.
11779 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11780
11781 # Check if the provided tool contains a complete path.
11782 tool_specified="$GREP"
11783 tool_basename="${tool_specified##*/}"
11784 if test "x$tool_basename" = "x$tool_specified"; then
11785 # A command without a complete path is provided, search $PATH.
11786 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11787 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11788 # Extract the first word of "$tool_basename", so it can be a program name with args.
11789 set dummy $tool_basename; ac_word=$2
11790 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11791 $as_echo_n "checking for $ac_word... " >&6; }
11792 if ${ac_cv_path_GREP+:} false; then :
11793 $as_echo_n "(cached) " >&6
11794 else
11795 case $GREP in
11796 [\\/]* | ?:[\\/]*)
11797 ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11798 ;;
11799 *)
11800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11801 for as_dir in $PATH
11802 do
11803 IFS=$as_save_IFS
11804 test -z "$as_dir" && as_dir=.
11805 for ac_exec_ext in '' $ac_executable_extensions; do
11806 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11807 ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11808 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11809 break 2
11810 fi
11811 done
11812 done
11813 IFS=$as_save_IFS
11814
11815 ;;
11816 esac
11817 fi
11818 GREP=$ac_cv_path_GREP
11819 if test -n "$GREP"; then
11820 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11821 $as_echo "$GREP" >&6; }
11822 else
11823 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11824 $as_echo "no" >&6; }
11825 fi
11826
11827
11828 if test "x$GREP" = x; then
11829 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11830 fi
11831 else
11832 # Otherwise we believe it is a complete path. Use it as it is.
11833 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11834 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11836 $as_echo_n "checking for GREP... " >&6; }
11837 if test ! -x "$tool_specified"; then
11838 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11839 $as_echo "not found" >&6; }
11840 as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11841 fi
11842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11843 $as_echo "$tool_specified" >&6; }
11844 fi
11845 fi
11846 fi
11847
11848
11849 if test "x$GREP" = x; then
11850 as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11851 fi
11852
11853
11854
11855
11856 # Publish this variable in the help.
11857
11858
11859 if test "x$EGREP" = x; then
11860 # The variable is not set by user, try to locate tool using the code snippet
11861 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11862 $as_echo_n "checking for egrep... " >&6; }
11863 if ${ac_cv_path_EGREP+:} false; then :
11864 $as_echo_n "(cached) " >&6
11865 else
11866 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11867 then ac_cv_path_EGREP="$GREP -E"
11868 else
11869 if test -z "$EGREP"; then
11870 ac_path_EGREP_found=false
11871 # Loop through the user's path and test for each of PROGNAME-LIST
11872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11873 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11874 do
11875 IFS=$as_save_IFS
11876 test -z "$as_dir" && as_dir=.
11877 for ac_prog in egrep; do
11878 for ac_exec_ext in '' $ac_executable_extensions; do
11879 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11880 as_fn_executable_p "$ac_path_EGREP" || continue
11881 # Check for GNU ac_path_EGREP and select it if it is found.
11882 # Check for GNU $ac_path_EGREP
11883 case `"$ac_path_EGREP" --version 2>&1` in
11884 *GNU*)
11885 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11886 *)
11887 ac_count=0
11888 $as_echo_n 0123456789 >"conftest.in"
11889 while :
11890 do
11891 cat "conftest.in" "conftest.in" >"conftest.tmp"
11892 mv "conftest.tmp" "conftest.in"
11893 cp "conftest.in" "conftest.nl"
11894 $as_echo 'EGREP' >> "conftest.nl"
11895 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11896 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11897 as_fn_arith $ac_count + 1 && ac_count=$as_val
11898 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11899 # Best one so far, save it but keep looking for a better one
11900 ac_cv_path_EGREP="$ac_path_EGREP"
11901 ac_path_EGREP_max=$ac_count
11902 fi
11903 # 10*(2^10) chars as input seems more than enough
11904 test $ac_count -gt 10 && break
11905 done
11906 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11907 esac
11908
11909 $ac_path_EGREP_found && break 3
11910 done
11911 done
11912 done
11913 IFS=$as_save_IFS
11914 if test -z "$ac_cv_path_EGREP"; then
11915 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11916 fi
11917 else
11918 ac_cv_path_EGREP=$EGREP
11919 fi
11920
11921 fi
11922 fi
11923 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11924 $as_echo "$ac_cv_path_EGREP" >&6; }
11925 EGREP="$ac_cv_path_EGREP"
11926
11927
11928 else
11929 # The variable is set, but is it from the command line or the environment?
11930
11931 # Try to remove the string !EGREP! from our list.
11932 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11933 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11934 # If it failed, the variable was not from the command line. Ignore it,
11935 # but warn the user (except for BASH, which is always set by the calling BASH).
11936 if test "xEGREP" != xBASH; then
11937 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11938 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11939 fi
11940 # Try to locate tool using the code snippet
11941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11942 $as_echo_n "checking for egrep... " >&6; }
11943 if ${ac_cv_path_EGREP+:} false; then :
11944 $as_echo_n "(cached) " >&6
11945 else
11946 if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11947 then ac_cv_path_EGREP="$GREP -E"
11948 else
11949 if test -z "$EGREP"; then
11950 ac_path_EGREP_found=false
11951 # Loop through the user's path and test for each of PROGNAME-LIST
11952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11953 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11954 do
11955 IFS=$as_save_IFS
11956 test -z "$as_dir" && as_dir=.
11957 for ac_prog in egrep; do
11958 for ac_exec_ext in '' $ac_executable_extensions; do
11959 ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11960 as_fn_executable_p "$ac_path_EGREP" || continue
11961 # Check for GNU ac_path_EGREP and select it if it is found.
11962 # Check for GNU $ac_path_EGREP
11963 case `"$ac_path_EGREP" --version 2>&1` in
11964 *GNU*)
11965 ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11966 *)
11967 ac_count=0
11968 $as_echo_n 0123456789 >"conftest.in"
11969 while :
11970 do
11971 cat "conftest.in" "conftest.in" >"conftest.tmp"
11972 mv "conftest.tmp" "conftest.in"
11973 cp "conftest.in" "conftest.nl"
11974 $as_echo 'EGREP' >> "conftest.nl"
11975 "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11976 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11977 as_fn_arith $ac_count + 1 && ac_count=$as_val
11978 if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11979 # Best one so far, save it but keep looking for a better one
11980 ac_cv_path_EGREP="$ac_path_EGREP"
11981 ac_path_EGREP_max=$ac_count
11982 fi
11983 # 10*(2^10) chars as input seems more than enough
11984 test $ac_count -gt 10 && break
11985 done
11986 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11987 esac
11988
11989 $ac_path_EGREP_found && break 3
11990 done
11991 done
11992 done
11993 IFS=$as_save_IFS
11994 if test -z "$ac_cv_path_EGREP"; then
11995 as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11996 fi
11997 else
11998 ac_cv_path_EGREP=$EGREP
11999 fi
12000
12001 fi
12002 fi
12003 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12004 $as_echo "$ac_cv_path_EGREP" >&6; }
12005 EGREP="$ac_cv_path_EGREP"
12006
12007
12008 else
12009 # If it succeeded, then it was overridden by the user. We will use it
12010 # for the tool.
12011
12012 # First remove it from the list of overridden variables, so we can test
12013 # for unknown variables in the end.
12014 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12015
12016 # Check if the provided tool contains a complete path.
12017 tool_specified="$EGREP"
12018 tool_basename="${tool_specified##*/}"
12019 if test "x$tool_basename" = "x$tool_specified"; then
12020 # A command without a complete path is provided, search $PATH.
12021 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
12022 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
12023 # Extract the first word of "$tool_basename", so it can be a program name with args.
12024 set dummy $tool_basename; ac_word=$2
12025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12026 $as_echo_n "checking for $ac_word... " >&6; }
12027 if ${ac_cv_path_EGREP+:} false; then :
12028 $as_echo_n "(cached) " >&6
12029 else
12030 case $EGREP in
12031 [\\/]* | ?:[\\/]*)
12032 ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
12033 ;;
12034 *)
12035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12036 for as_dir in $PATH
12037 do
12038 IFS=$as_save_IFS
12039 test -z "$as_dir" && as_dir=.
12040 for ac_exec_ext in '' $ac_executable_extensions; do
12041 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12042 ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
12043 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12044 break 2
12045 fi
12046 done
12047 done
12048 IFS=$as_save_IFS
12049
12050 ;;
12051 esac
12052 fi
12053 EGREP=$ac_cv_path_EGREP
12054 if test -n "$EGREP"; then
12055 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
12056 $as_echo "$EGREP" >&6; }
12057 else
12058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12059 $as_echo "no" >&6; }
12060 fi
12061
12062
12063 if test "x$EGREP" = x; then
12064 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12065 fi
12066 else
12067 # Otherwise we believe it is a complete path. Use it as it is.
12068 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12069 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12071 $as_echo_n "checking for EGREP... " >&6; }
12072 if test ! -x "$tool_specified"; then
12073 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12074 $as_echo "not found" >&6; }
12075 as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12076 fi
12077 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12078 $as_echo "$tool_specified" >&6; }
12079 fi
12080 fi
12081 fi
12082
12083
12084 if test "x$EGREP" = x; then
12085 as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12086 fi
12087
12088
12089
12090
12091 # Publish this variable in the help.
12092
12093
12094 if test "x$FGREP" = x; then
12095 # The variable is not set by user, try to locate tool using the code snippet
12096 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12097 $as_echo_n "checking for fgrep... " >&6; }
12098 if ${ac_cv_path_FGREP+:} false; then :
12099 $as_echo_n "(cached) " >&6
12100 else
12101 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12102 then ac_cv_path_FGREP="$GREP -F"
12103 else
12104 if test -z "$FGREP"; then
12105 ac_path_FGREP_found=false
12106 # Loop through the user's path and test for each of PROGNAME-LIST
12107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12108 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12109 do
12110 IFS=$as_save_IFS
12111 test -z "$as_dir" && as_dir=.
12112 for ac_prog in fgrep; do
12113 for ac_exec_ext in '' $ac_executable_extensions; do
12114 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12115 as_fn_executable_p "$ac_path_FGREP" || continue
12116 # Check for GNU ac_path_FGREP and select it if it is found.
12117 # Check for GNU $ac_path_FGREP
12118 case `"$ac_path_FGREP" --version 2>&1` in
12119 *GNU*)
12120 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12121 *)
12122 ac_count=0
12123 $as_echo_n 0123456789 >"conftest.in"
12124 while :
12125 do
12126 cat "conftest.in" "conftest.in" >"conftest.tmp"
12127 mv "conftest.tmp" "conftest.in"
12128 cp "conftest.in" "conftest.nl"
12129 $as_echo 'FGREP' >> "conftest.nl"
12130 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12131 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12132 as_fn_arith $ac_count + 1 && ac_count=$as_val
12133 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12134 # Best one so far, save it but keep looking for a better one
12135 ac_cv_path_FGREP="$ac_path_FGREP"
12136 ac_path_FGREP_max=$ac_count
12137 fi
12138 # 10*(2^10) chars as input seems more than enough
12139 test $ac_count -gt 10 && break
12140 done
12141 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12142 esac
12143
12144 $ac_path_FGREP_found && break 3
12145 done
12146 done
12147 done
12148 IFS=$as_save_IFS
12149 if test -z "$ac_cv_path_FGREP"; then
12150 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12151 fi
12152 else
12153 ac_cv_path_FGREP=$FGREP
12154 fi
12155
12156 fi
12157 fi
12158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12159 $as_echo "$ac_cv_path_FGREP" >&6; }
12160 FGREP="$ac_cv_path_FGREP"
12161
12162
12163 else
12164 # The variable is set, but is it from the command line or the environment?
12165
12166 # Try to remove the string !FGREP! from our list.
12167 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12168 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12169 # If it failed, the variable was not from the command line. Ignore it,
12170 # but warn the user (except for BASH, which is always set by the calling BASH).
12171 if test "xFGREP" != xBASH; then
12172 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12173 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12174 fi
12175 # Try to locate tool using the code snippet
12176 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12177 $as_echo_n "checking for fgrep... " >&6; }
12178 if ${ac_cv_path_FGREP+:} false; then :
12179 $as_echo_n "(cached) " >&6
12180 else
12181 if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12182 then ac_cv_path_FGREP="$GREP -F"
12183 else
12184 if test -z "$FGREP"; then
12185 ac_path_FGREP_found=false
12186 # Loop through the user's path and test for each of PROGNAME-LIST
12187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12188 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12189 do
12190 IFS=$as_save_IFS
12191 test -z "$as_dir" && as_dir=.
12192 for ac_prog in fgrep; do
12193 for ac_exec_ext in '' $ac_executable_extensions; do
12194 ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12195 as_fn_executable_p "$ac_path_FGREP" || continue
12196 # Check for GNU ac_path_FGREP and select it if it is found.
12197 # Check for GNU $ac_path_FGREP
12198 case `"$ac_path_FGREP" --version 2>&1` in
12199 *GNU*)
12200 ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12201 *)
12202 ac_count=0
12203 $as_echo_n 0123456789 >"conftest.in"
12204 while :
12205 do
12206 cat "conftest.in" "conftest.in" >"conftest.tmp"
12207 mv "conftest.tmp" "conftest.in"
12208 cp "conftest.in" "conftest.nl"
12209 $as_echo 'FGREP' >> "conftest.nl"
12210 "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12211 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12212 as_fn_arith $ac_count + 1 && ac_count=$as_val
12213 if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12214 # Best one so far, save it but keep looking for a better one
12215 ac_cv_path_FGREP="$ac_path_FGREP"
12216 ac_path_FGREP_max=$ac_count
12217 fi
12218 # 10*(2^10) chars as input seems more than enough
12219 test $ac_count -gt 10 && break
12220 done
12221 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12222 esac
12223
12224 $ac_path_FGREP_found && break 3
12225 done
12226 done
12227 done
12228 IFS=$as_save_IFS
12229 if test -z "$ac_cv_path_FGREP"; then
12230 as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12231 fi
12232 else
12233 ac_cv_path_FGREP=$FGREP
12234 fi
12235
12236 fi
12237 fi
12238 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12239 $as_echo "$ac_cv_path_FGREP" >&6; }
12240 FGREP="$ac_cv_path_FGREP"
12241
12242
12243 else
12244 # If it succeeded, then it was overridden by the user. We will use it
12245 # for the tool.
12246
12247 # First remove it from the list of overridden variables, so we can test
12248 # for unknown variables in the end.
12249 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12250
12251 # Check if the provided tool contains a complete path.
12252 tool_specified="$FGREP"
12253 tool_basename="${tool_specified##*/}"
12254 if test "x$tool_basename" = "x$tool_specified"; then
12255 # A command without a complete path is provided, search $PATH.
12256 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12257 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12258 # Extract the first word of "$tool_basename", so it can be a program name with args.
12259 set dummy $tool_basename; ac_word=$2
12260 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12261 $as_echo_n "checking for $ac_word... " >&6; }
12262 if ${ac_cv_path_FGREP+:} false; then :
12263 $as_echo_n "(cached) " >&6
12264 else
12265 case $FGREP in
12266 [\\/]* | ?:[\\/]*)
12267 ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12268 ;;
12269 *)
12270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12271 for as_dir in $PATH
12272 do
12273 IFS=$as_save_IFS
12274 test -z "$as_dir" && as_dir=.
12275 for ac_exec_ext in '' $ac_executable_extensions; do
12276 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12277 ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12278 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12279 break 2
12280 fi
12281 done
12282 done
12283 IFS=$as_save_IFS
12284
12285 ;;
12286 esac
12287 fi
12288 FGREP=$ac_cv_path_FGREP
12289 if test -n "$FGREP"; then
12290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12291 $as_echo "$FGREP" >&6; }
12292 else
12293 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12294 $as_echo "no" >&6; }
12295 fi
12296
12297
12298 if test "x$FGREP" = x; then
12299 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12300 fi
12301 else
12302 # Otherwise we believe it is a complete path. Use it as it is.
12303 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12304 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12306 $as_echo_n "checking for FGREP... " >&6; }
12307 if test ! -x "$tool_specified"; then
12308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12309 $as_echo "not found" >&6; }
12310 as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12311 fi
12312 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12313 $as_echo "$tool_specified" >&6; }
12314 fi
12315 fi
12316 fi
12317
12318
12319 if test "x$FGREP" = x; then
12320 as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12321 fi
12322
12323
12324
12325
12326 # Publish this variable in the help.
12327
12328
12329 if test "x$SED" = x; then
12330 # The variable is not set by user, try to locate tool using the code snippet
12331 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12332 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12333 if ${ac_cv_path_SED+:} false; then :
12334 $as_echo_n "(cached) " >&6
12335 else
12336 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12337 for ac_i in 1 2 3 4 5 6 7; do
12338 ac_script="$ac_script$as_nl$ac_script"
12339 done
12340 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12341 { ac_script=; unset ac_script;}
12342 if test -z "$SED"; then
12343 ac_path_SED_found=false
12344 # Loop through the user's path and test for each of PROGNAME-LIST
12345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12346 for as_dir in $PATH
12347 do
12348 IFS=$as_save_IFS
12349 test -z "$as_dir" && as_dir=.
12350 for ac_prog in sed gsed; do
12351 for ac_exec_ext in '' $ac_executable_extensions; do
12352 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12353 as_fn_executable_p "$ac_path_SED" || continue
12354 # Check for GNU ac_path_SED and select it if it is found.
12355 # Check for GNU $ac_path_SED
12356 case `"$ac_path_SED" --version 2>&1` in
12357 *GNU*)
12358 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12359 *)
12360 ac_count=0
12361 $as_echo_n 0123456789 >"conftest.in"
12362 while :
12363 do
12364 cat "conftest.in" "conftest.in" >"conftest.tmp"
12365 mv "conftest.tmp" "conftest.in"
12366 cp "conftest.in" "conftest.nl"
12367 $as_echo '' >> "conftest.nl"
12368 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12369 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12370 as_fn_arith $ac_count + 1 && ac_count=$as_val
12371 if test $ac_count -gt ${ac_path_SED_max-0}; then
12372 # Best one so far, save it but keep looking for a better one
12373 ac_cv_path_SED="$ac_path_SED"
12374 ac_path_SED_max=$ac_count
12375 fi
12376 # 10*(2^10) chars as input seems more than enough
12377 test $ac_count -gt 10 && break
12378 done
12379 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12380 esac
12381
12382 $ac_path_SED_found && break 3
12383 done
12384 done
12385 done
12386 IFS=$as_save_IFS
12387 if test -z "$ac_cv_path_SED"; then
12388 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12389 fi
12390 else
12391 ac_cv_path_SED=$SED
12392 fi
12393
12394 fi
12395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12396 $as_echo "$ac_cv_path_SED" >&6; }
12397 SED="$ac_cv_path_SED"
12398 rm -f conftest.sed
12399
12400 else
12401 # The variable is set, but is it from the command line or the environment?
12402
12403 # Try to remove the string !SED! from our list.
12404 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12405 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12406 # If it failed, the variable was not from the command line. Ignore it,
12407 # but warn the user (except for BASH, which is always set by the calling BASH).
12408 if test "xSED" != xBASH; then
12409 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12410 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12411 fi
12412 # Try to locate tool using the code snippet
12413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12414 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12415 if ${ac_cv_path_SED+:} false; then :
12416 $as_echo_n "(cached) " >&6
12417 else
12418 ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12419 for ac_i in 1 2 3 4 5 6 7; do
12420 ac_script="$ac_script$as_nl$ac_script"
12421 done
12422 echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12423 { ac_script=; unset ac_script;}
12424 if test -z "$SED"; then
12425 ac_path_SED_found=false
12426 # Loop through the user's path and test for each of PROGNAME-LIST
12427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12428 for as_dir in $PATH
12429 do
12430 IFS=$as_save_IFS
12431 test -z "$as_dir" && as_dir=.
12432 for ac_prog in sed gsed; do
12433 for ac_exec_ext in '' $ac_executable_extensions; do
12434 ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12435 as_fn_executable_p "$ac_path_SED" || continue
12436 # Check for GNU ac_path_SED and select it if it is found.
12437 # Check for GNU $ac_path_SED
12438 case `"$ac_path_SED" --version 2>&1` in
12439 *GNU*)
12440 ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12441 *)
12442 ac_count=0
12443 $as_echo_n 0123456789 >"conftest.in"
12444 while :
12445 do
12446 cat "conftest.in" "conftest.in" >"conftest.tmp"
12447 mv "conftest.tmp" "conftest.in"
12448 cp "conftest.in" "conftest.nl"
12449 $as_echo '' >> "conftest.nl"
12450 "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12451 diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12452 as_fn_arith $ac_count + 1 && ac_count=$as_val
12453 if test $ac_count -gt ${ac_path_SED_max-0}; then
12454 # Best one so far, save it but keep looking for a better one
12455 ac_cv_path_SED="$ac_path_SED"
12456 ac_path_SED_max=$ac_count
12457 fi
12458 # 10*(2^10) chars as input seems more than enough
12459 test $ac_count -gt 10 && break
12460 done
12461 rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12462 esac
12463
12464 $ac_path_SED_found && break 3
12465 done
12466 done
12467 done
12468 IFS=$as_save_IFS
12469 if test -z "$ac_cv_path_SED"; then
12470 as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12471 fi
12472 else
12473 ac_cv_path_SED=$SED
12474 fi
12475
12476 fi
12477 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12478 $as_echo "$ac_cv_path_SED" >&6; }
12479 SED="$ac_cv_path_SED"
12480 rm -f conftest.sed
12481
12482 else
12483 # If it succeeded, then it was overridden by the user. We will use it
12484 # for the tool.
12485
12486 # First remove it from the list of overridden variables, so we can test
12487 # for unknown variables in the end.
12488 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12489
12490 # Check if the provided tool contains a complete path.
12491 tool_specified="$SED"
12492 tool_basename="${tool_specified##*/}"
12493 if test "x$tool_basename" = "x$tool_specified"; then
12494 # A command without a complete path is provided, search $PATH.
12495 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12496 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12497 # Extract the first word of "$tool_basename", so it can be a program name with args.
12498 set dummy $tool_basename; ac_word=$2
12499 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12500 $as_echo_n "checking for $ac_word... " >&6; }
12501 if ${ac_cv_path_SED+:} false; then :
12502 $as_echo_n "(cached) " >&6
12503 else
12504 case $SED in
12505 [\\/]* | ?:[\\/]*)
12506 ac_cv_path_SED="$SED" # Let the user override the test with a path.
12507 ;;
12508 *)
12509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12510 for as_dir in $PATH
12511 do
12512 IFS=$as_save_IFS
12513 test -z "$as_dir" && as_dir=.
12514 for ac_exec_ext in '' $ac_executable_extensions; do
12515 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12516 ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12517 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12518 break 2
12519 fi
12520 done
12521 done
12522 IFS=$as_save_IFS
12523
12524 ;;
12525 esac
12526 fi
12527 SED=$ac_cv_path_SED
12528 if test -n "$SED"; then
12529 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12530 $as_echo "$SED" >&6; }
12531 else
12532 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12533 $as_echo "no" >&6; }
12534 fi
12535
12536
12537 if test "x$SED" = x; then
12538 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12539 fi
12540 else
12541 # Otherwise we believe it is a complete path. Use it as it is.
12542 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12543 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12545 $as_echo_n "checking for SED... " >&6; }
12546 if test ! -x "$tool_specified"; then
12547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12548 $as_echo "not found" >&6; }
12549 as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12550 fi
12551 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12552 $as_echo "$tool_specified" >&6; }
12553 fi
12554 fi
12555 fi
12556
12557
12558 if test "x$SED" = x; then
12559 as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12560 fi
12561
12562
12563
12564 # Always force rm.
12565 RM="$RM -f"
12566
12567 # pwd behaves differently on various platforms and some don't support the -L flag.
12568 # Always use the bash builtin pwd to get uniform behavior.
12569 THEPWDCMD=pwd
12570
12571 # These are not required on all platforms
12572
12573
12574 # Publish this variable in the help.
12575
12576
12577 if test "x$CYGPATH" = x; then
12578 # The variable is not set by user, try to locate tool using the code snippet
12579 for ac_prog in cygpath
12580 do
12581 # Extract the first word of "$ac_prog", so it can be a program name with args.
12582 set dummy $ac_prog; ac_word=$2
12583 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12584 $as_echo_n "checking for $ac_word... " >&6; }
12585 if ${ac_cv_path_CYGPATH+:} false; then :
12586 $as_echo_n "(cached) " >&6
12587 else
12588 case $CYGPATH in
12589 [\\/]* | ?:[\\/]*)
12590 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12591 ;;
12592 *)
12593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12594 for as_dir in $PATH
12595 do
12596 IFS=$as_save_IFS
12597 test -z "$as_dir" && as_dir=.
12598 for ac_exec_ext in '' $ac_executable_extensions; do
12599 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12600 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12601 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12602 break 2
12603 fi
12604 done
12605 done
12606 IFS=$as_save_IFS
12607
12608 ;;
12609 esac
12610 fi
12611 CYGPATH=$ac_cv_path_CYGPATH
12612 if test -n "$CYGPATH"; then
12613 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12614 $as_echo "$CYGPATH" >&6; }
12615 else
12616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12617 $as_echo "no" >&6; }
12618 fi
12619
12620
12621 test -n "$CYGPATH" && break
12622 done
12623
12624 else
12625 # The variable is set, but is it from the command line or the environment?
12626
12627 # Try to remove the string !CYGPATH! from our list.
12628 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12629 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12630 # If it failed, the variable was not from the command line. Ignore it,
12631 # but warn the user (except for BASH, which is always set by the calling BASH).
12632 if test "xCYGPATH" != xBASH; then
12633 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12634 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12635 fi
12636 # Try to locate tool using the code snippet
12637 for ac_prog in cygpath
12638 do
12639 # Extract the first word of "$ac_prog", so it can be a program name with args.
12640 set dummy $ac_prog; ac_word=$2
12641 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12642 $as_echo_n "checking for $ac_word... " >&6; }
12643 if ${ac_cv_path_CYGPATH+:} false; then :
12644 $as_echo_n "(cached) " >&6
12645 else
12646 case $CYGPATH in
12647 [\\/]* | ?:[\\/]*)
12648 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12649 ;;
12650 *)
12651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12652 for as_dir in $PATH
12653 do
12654 IFS=$as_save_IFS
12655 test -z "$as_dir" && as_dir=.
12656 for ac_exec_ext in '' $ac_executable_extensions; do
12657 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12658 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12659 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12660 break 2
12661 fi
12662 done
12663 done
12664 IFS=$as_save_IFS
12665
12666 ;;
12667 esac
12668 fi
12669 CYGPATH=$ac_cv_path_CYGPATH
12670 if test -n "$CYGPATH"; then
12671 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12672 $as_echo "$CYGPATH" >&6; }
12673 else
12674 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12675 $as_echo "no" >&6; }
12676 fi
12677
12678
12679 test -n "$CYGPATH" && break
12680 done
12681
12682 else
12683 # If it succeeded, then it was overridden by the user. We will use it
12684 # for the tool.
12685
12686 # First remove it from the list of overridden variables, so we can test
12687 # for unknown variables in the end.
12688 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12689
12690 # Check if the provided tool contains a complete path.
12691 tool_specified="$CYGPATH"
12692 tool_basename="${tool_specified##*/}"
12693 if test "x$tool_basename" = "x$tool_specified"; then
12694 # A command without a complete path is provided, search $PATH.
12695 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12696 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12697 # Extract the first word of "$tool_basename", so it can be a program name with args.
12698 set dummy $tool_basename; ac_word=$2
12699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12700 $as_echo_n "checking for $ac_word... " >&6; }
12701 if ${ac_cv_path_CYGPATH+:} false; then :
12702 $as_echo_n "(cached) " >&6
12703 else
12704 case $CYGPATH in
12705 [\\/]* | ?:[\\/]*)
12706 ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12707 ;;
12708 *)
12709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12710 for as_dir in $PATH
12711 do
12712 IFS=$as_save_IFS
12713 test -z "$as_dir" && as_dir=.
12714 for ac_exec_ext in '' $ac_executable_extensions; do
12715 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12716 ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12717 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12718 break 2
12719 fi
12720 done
12721 done
12722 IFS=$as_save_IFS
12723
12724 ;;
12725 esac
12726 fi
12727 CYGPATH=$ac_cv_path_CYGPATH
12728 if test -n "$CYGPATH"; then
12729 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12730 $as_echo "$CYGPATH" >&6; }
12731 else
12732 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12733 $as_echo "no" >&6; }
12734 fi
12735
12736
12737 if test "x$CYGPATH" = x; then
12738 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12739 fi
12740 else
12741 # Otherwise we believe it is a complete path. Use it as it is.
12742 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12743 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12744 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12745 $as_echo_n "checking for CYGPATH... " >&6; }
12746 if test ! -x "$tool_specified"; then
12747 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12748 $as_echo "not found" >&6; }
12749 as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12750 fi
12751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12752 $as_echo "$tool_specified" >&6; }
12753 fi
12754 fi
12755 fi
12756
12757
12758
12759
12760 # Publish this variable in the help.
12761
12762
12763 if test "x$READLINK" = x; then
12764 # The variable is not set by user, try to locate tool using the code snippet
12765 for ac_prog in greadlink readlink
12766 do
12767 # Extract the first word of "$ac_prog", so it can be a program name with args.
12768 set dummy $ac_prog; ac_word=$2
12769 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12770 $as_echo_n "checking for $ac_word... " >&6; }
12771 if ${ac_cv_path_READLINK+:} false; then :
12772 $as_echo_n "(cached) " >&6
12773 else
12774 case $READLINK in
12775 [\\/]* | ?:[\\/]*)
12776 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12777 ;;
12778 *)
12779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12780 for as_dir in $PATH
12781 do
12782 IFS=$as_save_IFS
12783 test -z "$as_dir" && as_dir=.
12784 for ac_exec_ext in '' $ac_executable_extensions; do
12785 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12786 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12787 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12788 break 2
12789 fi
12790 done
12791 done
12792 IFS=$as_save_IFS
12793
12794 ;;
12795 esac
12796 fi
12797 READLINK=$ac_cv_path_READLINK
12798 if test -n "$READLINK"; then
12799 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12800 $as_echo "$READLINK" >&6; }
12801 else
12802 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12803 $as_echo "no" >&6; }
12804 fi
12805
12806
12807 test -n "$READLINK" && break
12808 done
12809
12810 else
12811 # The variable is set, but is it from the command line or the environment?
12812
12813 # Try to remove the string !READLINK! from our list.
12814 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12815 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12816 # If it failed, the variable was not from the command line. Ignore it,
12817 # but warn the user (except for BASH, which is always set by the calling BASH).
12818 if test "xREADLINK" != xBASH; then
12819 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12820 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12821 fi
12822 # Try to locate tool using the code snippet
12823 for ac_prog in greadlink readlink
12824 do
12825 # Extract the first word of "$ac_prog", so it can be a program name with args.
12826 set dummy $ac_prog; ac_word=$2
12827 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12828 $as_echo_n "checking for $ac_word... " >&6; }
12829 if ${ac_cv_path_READLINK+:} false; then :
12830 $as_echo_n "(cached) " >&6
12831 else
12832 case $READLINK in
12833 [\\/]* | ?:[\\/]*)
12834 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12835 ;;
12836 *)
12837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12838 for as_dir in $PATH
12839 do
12840 IFS=$as_save_IFS
12841 test -z "$as_dir" && as_dir=.
12842 for ac_exec_ext in '' $ac_executable_extensions; do
12843 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12844 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12845 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12846 break 2
12847 fi
12848 done
12849 done
12850 IFS=$as_save_IFS
12851
12852 ;;
12853 esac
12854 fi
12855 READLINK=$ac_cv_path_READLINK
12856 if test -n "$READLINK"; then
12857 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12858 $as_echo "$READLINK" >&6; }
12859 else
12860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12861 $as_echo "no" >&6; }
12862 fi
12863
12864
12865 test -n "$READLINK" && break
12866 done
12867
12868 else
12869 # If it succeeded, then it was overridden by the user. We will use it
12870 # for the tool.
12871
12872 # First remove it from the list of overridden variables, so we can test
12873 # for unknown variables in the end.
12874 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12875
12876 # Check if the provided tool contains a complete path.
12877 tool_specified="$READLINK"
12878 tool_basename="${tool_specified##*/}"
12879 if test "x$tool_basename" = "x$tool_specified"; then
12880 # A command without a complete path is provided, search $PATH.
12881 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12882 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12883 # Extract the first word of "$tool_basename", so it can be a program name with args.
12884 set dummy $tool_basename; ac_word=$2
12885 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12886 $as_echo_n "checking for $ac_word... " >&6; }
12887 if ${ac_cv_path_READLINK+:} false; then :
12888 $as_echo_n "(cached) " >&6
12889 else
12890 case $READLINK in
12891 [\\/]* | ?:[\\/]*)
12892 ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12893 ;;
12894 *)
12895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12896 for as_dir in $PATH
12897 do
12898 IFS=$as_save_IFS
12899 test -z "$as_dir" && as_dir=.
12900 for ac_exec_ext in '' $ac_executable_extensions; do
12901 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12902 ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12903 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12904 break 2
12905 fi
12906 done
12907 done
12908 IFS=$as_save_IFS
12909
12910 ;;
12911 esac
12912 fi
12913 READLINK=$ac_cv_path_READLINK
12914 if test -n "$READLINK"; then
12915 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12916 $as_echo "$READLINK" >&6; }
12917 else
12918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12919 $as_echo "no" >&6; }
12920 fi
12921
12922
12923 if test "x$READLINK" = x; then
12924 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12925 fi
12926 else
12927 # Otherwise we believe it is a complete path. Use it as it is.
12928 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12929 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12930 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12931 $as_echo_n "checking for READLINK... " >&6; }
12932 if test ! -x "$tool_specified"; then
12933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12934 $as_echo "not found" >&6; }
12935 as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12936 fi
12937 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12938 $as_echo "$tool_specified" >&6; }
12939 fi
12940 fi
12941 fi
12942
12943
12944
12945
12946 # Publish this variable in the help.
12947
12948
12949 if test "x$DF" = x; then
12950 # The variable is not set by user, try to locate tool using the code snippet
12951 for ac_prog in df
12952 do
12953 # Extract the first word of "$ac_prog", so it can be a program name with args.
12954 set dummy $ac_prog; ac_word=$2
12955 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12956 $as_echo_n "checking for $ac_word... " >&6; }
12957 if ${ac_cv_path_DF+:} false; then :
12958 $as_echo_n "(cached) " >&6
12959 else
12960 case $DF in
12961 [\\/]* | ?:[\\/]*)
12962 ac_cv_path_DF="$DF" # Let the user override the test with a path.
12963 ;;
12964 *)
12965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12966 for as_dir in $PATH
12967 do
12968 IFS=$as_save_IFS
12969 test -z "$as_dir" && as_dir=.
12970 for ac_exec_ext in '' $ac_executable_extensions; do
12971 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12972 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12973 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12974 break 2
12975 fi
12976 done
12977 done
12978 IFS=$as_save_IFS
12979
12980 ;;
12981 esac
12982 fi
12983 DF=$ac_cv_path_DF
12984 if test -n "$DF"; then
12985 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12986 $as_echo "$DF" >&6; }
12987 else
12988 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12989 $as_echo "no" >&6; }
12990 fi
12991
12992
12993 test -n "$DF" && break
12994 done
12995
12996 else
12997 # The variable is set, but is it from the command line or the environment?
12998
12999 # Try to remove the string !DF! from our list.
13000 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
13001 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13002 # If it failed, the variable was not from the command line. Ignore it,
13003 # but warn the user (except for BASH, which is always set by the calling BASH).
13004 if test "xDF" != xBASH; then
13005 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
13006 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
13007 fi
13008 # Try to locate tool using the code snippet
13009 for ac_prog in df
13010 do
13011 # Extract the first word of "$ac_prog", so it can be a program name with args.
13012 set dummy $ac_prog; ac_word=$2
13013 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13014 $as_echo_n "checking for $ac_word... " >&6; }
13015 if ${ac_cv_path_DF+:} false; then :
13016 $as_echo_n "(cached) " >&6
13017 else
13018 case $DF in
13019 [\\/]* | ?:[\\/]*)
13020 ac_cv_path_DF="$DF" # Let the user override the test with a path.
13021 ;;
13022 *)
13023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13024 for as_dir in $PATH
13025 do
13026 IFS=$as_save_IFS
13027 test -z "$as_dir" && as_dir=.
13028 for ac_exec_ext in '' $ac_executable_extensions; do
13029 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13030 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13031 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13032 break 2
13033 fi
13034 done
13035 done
13036 IFS=$as_save_IFS
13037
13038 ;;
13039 esac
13040 fi
13041 DF=$ac_cv_path_DF
13042 if test -n "$DF"; then
13043 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13044 $as_echo "$DF" >&6; }
13045 else
13046 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13047 $as_echo "no" >&6; }
13048 fi
13049
13050
13051 test -n "$DF" && break
13052 done
13053
13054 else
13055 # If it succeeded, then it was overridden by the user. We will use it
13056 # for the tool.
13057
13058 # First remove it from the list of overridden variables, so we can test
13059 # for unknown variables in the end.
13060 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13061
13062 # Check if the provided tool contains a complete path.
13063 tool_specified="$DF"
13064 tool_basename="${tool_specified##*/}"
13065 if test "x$tool_basename" = "x$tool_specified"; then
13066 # A command without a complete path is provided, search $PATH.
13067 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
13068 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
13069 # Extract the first word of "$tool_basename", so it can be a program name with args.
13070 set dummy $tool_basename; ac_word=$2
13071 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13072 $as_echo_n "checking for $ac_word... " >&6; }
13073 if ${ac_cv_path_DF+:} false; then :
13074 $as_echo_n "(cached) " >&6
13075 else
13076 case $DF in
13077 [\\/]* | ?:[\\/]*)
13078 ac_cv_path_DF="$DF" # Let the user override the test with a path.
13079 ;;
13080 *)
13081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13082 for as_dir in $PATH
13083 do
13084 IFS=$as_save_IFS
13085 test -z "$as_dir" && as_dir=.
13086 for ac_exec_ext in '' $ac_executable_extensions; do
13087 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13088 ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13089 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13090 break 2
13091 fi
13092 done
13093 done
13094 IFS=$as_save_IFS
13095
13096 ;;
13097 esac
13098 fi
13099 DF=$ac_cv_path_DF
13100 if test -n "$DF"; then
13101 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13102 $as_echo "$DF" >&6; }
13103 else
13104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13105 $as_echo "no" >&6; }
13106 fi
13107
13108
13109 if test "x$DF" = x; then
13110 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13111 fi
13112 else
13113 # Otherwise we believe it is a complete path. Use it as it is.
13114 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13115 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13116 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13117 $as_echo_n "checking for DF... " >&6; }
13118 if test ! -x "$tool_specified"; then
13119 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13120 $as_echo "not found" >&6; }
13121 as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13122 fi
13123 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13124 $as_echo "$tool_specified" >&6; }
13125 fi
13126 fi
13127 fi
13128
13129
13130
13131
13132 # Publish this variable in the help.
13133
13134
13135 if test "x$SETFILE" = x; then
13136 # The variable is not set by user, try to locate tool using the code snippet
13137 for ac_prog in SetFile
13138 do
13139 # Extract the first word of "$ac_prog", so it can be a program name with args.
13140 set dummy $ac_prog; ac_word=$2
13141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13142 $as_echo_n "checking for $ac_word... " >&6; }
13143 if ${ac_cv_path_SETFILE+:} false; then :
13144 $as_echo_n "(cached) " >&6
13145 else
13146 case $SETFILE in
13147 [\\/]* | ?:[\\/]*)
13148 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13149 ;;
13150 *)
13151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13152 for as_dir in $PATH
13153 do
13154 IFS=$as_save_IFS
13155 test -z "$as_dir" && as_dir=.
13156 for ac_exec_ext in '' $ac_executable_extensions; do
13157 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13158 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13159 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13160 break 2
13161 fi
13162 done
13163 done
13164 IFS=$as_save_IFS
13165
13166 ;;
13167 esac
13168 fi
13169 SETFILE=$ac_cv_path_SETFILE
13170 if test -n "$SETFILE"; then
13171 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13172 $as_echo "$SETFILE" >&6; }
13173 else
13174 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13175 $as_echo "no" >&6; }
13176 fi
13177
13178
13179 test -n "$SETFILE" && break
13180 done
13181
13182 else
13183 # The variable is set, but is it from the command line or the environment?
13184
13185 # Try to remove the string !SETFILE! from our list.
13186 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13187 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13188 # If it failed, the variable was not from the command line. Ignore it,
13189 # but warn the user (except for BASH, which is always set by the calling BASH).
13190 if test "xSETFILE" != xBASH; then
13191 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13192 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13193 fi
13194 # Try to locate tool using the code snippet
13195 for ac_prog in SetFile
13196 do
13197 # Extract the first word of "$ac_prog", so it can be a program name with args.
13198 set dummy $ac_prog; ac_word=$2
13199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13200 $as_echo_n "checking for $ac_word... " >&6; }
13201 if ${ac_cv_path_SETFILE+:} false; then :
13202 $as_echo_n "(cached) " >&6
13203 else
13204 case $SETFILE in
13205 [\\/]* | ?:[\\/]*)
13206 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13207 ;;
13208 *)
13209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13210 for as_dir in $PATH
13211 do
13212 IFS=$as_save_IFS
13213 test -z "$as_dir" && as_dir=.
13214 for ac_exec_ext in '' $ac_executable_extensions; do
13215 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13216 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13217 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13218 break 2
13219 fi
13220 done
13221 done
13222 IFS=$as_save_IFS
13223
13224 ;;
13225 esac
13226 fi
13227 SETFILE=$ac_cv_path_SETFILE
13228 if test -n "$SETFILE"; then
13229 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13230 $as_echo "$SETFILE" >&6; }
13231 else
13232 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13233 $as_echo "no" >&6; }
13234 fi
13235
13236
13237 test -n "$SETFILE" && break
13238 done
13239
13240 else
13241 # If it succeeded, then it was overridden by the user. We will use it
13242 # for the tool.
13243
13244 # First remove it from the list of overridden variables, so we can test
13245 # for unknown variables in the end.
13246 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13247
13248 # Check if the provided tool contains a complete path.
13249 tool_specified="$SETFILE"
13250 tool_basename="${tool_specified##*/}"
13251 if test "x$tool_basename" = "x$tool_specified"; then
13252 # A command without a complete path is provided, search $PATH.
13253 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13254 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13255 # Extract the first word of "$tool_basename", so it can be a program name with args.
13256 set dummy $tool_basename; ac_word=$2
13257 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13258 $as_echo_n "checking for $ac_word... " >&6; }
13259 if ${ac_cv_path_SETFILE+:} false; then :
13260 $as_echo_n "(cached) " >&6
13261 else
13262 case $SETFILE in
13263 [\\/]* | ?:[\\/]*)
13264 ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13265 ;;
13266 *)
13267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13268 for as_dir in $PATH
13269 do
13270 IFS=$as_save_IFS
13271 test -z "$as_dir" && as_dir=.
13272 for ac_exec_ext in '' $ac_executable_extensions; do
13273 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13274 ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13275 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13276 break 2
13277 fi
13278 done
13279 done
13280 IFS=$as_save_IFS
13281
13282 ;;
13283 esac
13284 fi
13285 SETFILE=$ac_cv_path_SETFILE
13286 if test -n "$SETFILE"; then
13287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13288 $as_echo "$SETFILE" >&6; }
13289 else
13290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13291 $as_echo "no" >&6; }
13292 fi
13293
13294
13295 if test "x$SETFILE" = x; then
13296 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13297 fi
13298 else
13299 # Otherwise we believe it is a complete path. Use it as it is.
13300 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13301 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13303 $as_echo_n "checking for SETFILE... " >&6; }
13304 if test ! -x "$tool_specified"; then
13305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13306 $as_echo "not found" >&6; }
13307 as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13308 fi
13309 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13310 $as_echo "$tool_specified" >&6; }
13311 fi
13312 fi
13313 fi
13314
13315
13316
13317
13318 # Publish this variable in the help.
13319
13320
13321 if test "x$CPIO" = x; then
13322 # The variable is not set by user, try to locate tool using the code snippet
13323 for ac_prog in cpio bsdcpio
13324 do
13325 # Extract the first word of "$ac_prog", so it can be a program name with args.
13326 set dummy $ac_prog; ac_word=$2
13327 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13328 $as_echo_n "checking for $ac_word... " >&6; }
13329 if ${ac_cv_path_CPIO+:} false; then :
13330 $as_echo_n "(cached) " >&6
13331 else
13332 case $CPIO in
13333 [\\/]* | ?:[\\/]*)
13334 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13335 ;;
13336 *)
13337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13338 for as_dir in $PATH
13339 do
13340 IFS=$as_save_IFS
13341 test -z "$as_dir" && as_dir=.
13342 for ac_exec_ext in '' $ac_executable_extensions; do
13343 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13344 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13345 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13346 break 2
13347 fi
13348 done
13349 done
13350 IFS=$as_save_IFS
13351
13352 ;;
13353 esac
13354 fi
13355 CPIO=$ac_cv_path_CPIO
13356 if test -n "$CPIO"; then
13357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13358 $as_echo "$CPIO" >&6; }
13359 else
13360 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13361 $as_echo "no" >&6; }
13362 fi
13363
13364
13365 test -n "$CPIO" && break
13366 done
13367
13368 else
13369 # The variable is set, but is it from the command line or the environment?
13370
13371 # Try to remove the string !CPIO! from our list.
13372 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13373 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13374 # If it failed, the variable was not from the command line. Ignore it,
13375 # but warn the user (except for BASH, which is always set by the calling BASH).
13376 if test "xCPIO" != xBASH; then
13377 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13378 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13379 fi
13380 # Try to locate tool using the code snippet
13381 for ac_prog in cpio bsdcpio
13382 do
13383 # Extract the first word of "$ac_prog", so it can be a program name with args.
13384 set dummy $ac_prog; ac_word=$2
13385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13386 $as_echo_n "checking for $ac_word... " >&6; }
13387 if ${ac_cv_path_CPIO+:} false; then :
13388 $as_echo_n "(cached) " >&6
13389 else
13390 case $CPIO in
13391 [\\/]* | ?:[\\/]*)
13392 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13393 ;;
13394 *)
13395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13396 for as_dir in $PATH
13397 do
13398 IFS=$as_save_IFS
13399 test -z "$as_dir" && as_dir=.
13400 for ac_exec_ext in '' $ac_executable_extensions; do
13401 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13402 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13403 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13404 break 2
13405 fi
13406 done
13407 done
13408 IFS=$as_save_IFS
13409
13410 ;;
13411 esac
13412 fi
13413 CPIO=$ac_cv_path_CPIO
13414 if test -n "$CPIO"; then
13415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13416 $as_echo "$CPIO" >&6; }
13417 else
13418 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13419 $as_echo "no" >&6; }
13420 fi
13421
13422
13423 test -n "$CPIO" && break
13424 done
13425
13426 else
13427 # If it succeeded, then it was overridden by the user. We will use it
13428 # for the tool.
13429
13430 # First remove it from the list of overridden variables, so we can test
13431 # for unknown variables in the end.
13432 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13433
13434 # Check if the provided tool contains a complete path.
13435 tool_specified="$CPIO"
13436 tool_basename="${tool_specified##*/}"
13437 if test "x$tool_basename" = "x$tool_specified"; then
13438 # A command without a complete path is provided, search $PATH.
13439 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13440 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13441 # Extract the first word of "$tool_basename", so it can be a program name with args.
13442 set dummy $tool_basename; ac_word=$2
13443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13444 $as_echo_n "checking for $ac_word... " >&6; }
13445 if ${ac_cv_path_CPIO+:} false; then :
13446 $as_echo_n "(cached) " >&6
13447 else
13448 case $CPIO in
13449 [\\/]* | ?:[\\/]*)
13450 ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13451 ;;
13452 *)
13453 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13454 for as_dir in $PATH
13455 do
13456 IFS=$as_save_IFS
13457 test -z "$as_dir" && as_dir=.
13458 for ac_exec_ext in '' $ac_executable_extensions; do
13459 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13460 ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13461 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13462 break 2
13463 fi
13464 done
13465 done
13466 IFS=$as_save_IFS
13467
13468 ;;
13469 esac
13470 fi
13471 CPIO=$ac_cv_path_CPIO
13472 if test -n "$CPIO"; then
13473 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13474 $as_echo "$CPIO" >&6; }
13475 else
13476 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13477 $as_echo "no" >&6; }
13478 fi
13479
13480
13481 if test "x$CPIO" = x; then
13482 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13483 fi
13484 else
13485 # Otherwise we believe it is a complete path. Use it as it is.
13486 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13487 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13489 $as_echo_n "checking for CPIO... " >&6; }
13490 if test ! -x "$tool_specified"; then
13491 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13492 $as_echo "not found" >&6; }
13493 as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13494 fi
13495 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13496 $as_echo "$tool_specified" >&6; }
13497 fi
13498 fi
13499 fi
13500
13501
13502
13503
13504 # Now we can determine OpenJDK build and target platforms. This is required to
13505 # have early on.
13506 # Make sure we can run config.sub.
13507 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13508 as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13509
13510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13511 $as_echo_n "checking build system type... " >&6; }
13512 if ${ac_cv_build+:} false; then :
13513 $as_echo_n "(cached) " >&6
13514 else
13515 ac_build_alias=$build_alias
13516 test "x$ac_build_alias" = x &&
13517 ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13518 test "x$ac_build_alias" = x &&
13519 as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13520 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13521 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13522
13523 fi
13524 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13525 $as_echo "$ac_cv_build" >&6; }
13526 case $ac_cv_build in
13527 *-*-*) ;;
13528 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13529 esac
13530 build=$ac_cv_build
13531 ac_save_IFS=$IFS; IFS='-'
13532 set x $ac_cv_build
13533 shift
13534 build_cpu=$1
13535 build_vendor=$2
13536 shift; shift
13537 # Remember, the first character of IFS is used to create $*,
13538 # except with old shells:
13539 build_os=$*
13540 IFS=$ac_save_IFS
13541 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13542
13543
13544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13545 $as_echo_n "checking host system type... " >&6; }
13546 if ${ac_cv_host+:} false; then :
13547 $as_echo_n "(cached) " >&6
13548 else
13549 if test "x$host_alias" = x; then
13550 ac_cv_host=$ac_cv_build
13551 else
13552 ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13553 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13554 fi
13555
13556 fi
13557 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13558 $as_echo "$ac_cv_host" >&6; }
13559 case $ac_cv_host in
13560 *-*-*) ;;
13561 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13562 esac
13563 host=$ac_cv_host
13564 ac_save_IFS=$IFS; IFS='-'
13565 set x $ac_cv_host
13566 shift
13567 host_cpu=$1
13568 host_vendor=$2
13569 shift; shift
13570 # Remember, the first character of IFS is used to create $*,
13571 # except with old shells:
13572 host_os=$*
13573 IFS=$ac_save_IFS
13574 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13575
13576
13577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13578 $as_echo_n "checking target system type... " >&6; }
13579 if ${ac_cv_target+:} false; then :
13580 $as_echo_n "(cached) " >&6
13581 else
13582 if test "x$target_alias" = x; then
13583 ac_cv_target=$ac_cv_host
13584 else
13585 ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13586 as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13587 fi
13588
13589 fi
13590 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13591 $as_echo "$ac_cv_target" >&6; }
13592 case $ac_cv_target in
13593 *-*-*) ;;
13594 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13595 esac
13596 target=$ac_cv_target
13597 ac_save_IFS=$IFS; IFS='-'
13598 set x $ac_cv_target
13599 shift
13600 target_cpu=$1
13601 target_vendor=$2
13602 shift; shift
13603 # Remember, the first character of IFS is used to create $*,
13604 # except with old shells:
13605 target_os=$*
13606 IFS=$ac_save_IFS
13607 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13608
13609
13610 # The aliases save the names the user supplied, while $host etc.
13611 # will get canonicalized.
13612 test -n "$target_alias" &&
13613 test "$program_prefix$program_suffix$program_transform_name" = \
13614 NONENONEs,x,x, &&
13615 program_prefix=${target_alias}-
13616
13617 # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13618 # is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
13619 # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13620 # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13621 # to use the configure naming style.
13622
13623
13624
13625
13626
13627 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13628 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13629 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13630 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13631 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13632 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13633
13634
13635
13636 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13637
13638 case "$build_os" in
13639 *linux*)
13640 VAR_OS=linux
13641 VAR_OS_TYPE=unix
13642 ;;
13643 *solaris*)
13644 VAR_OS=solaris
13645 VAR_OS_TYPE=unix
13646 ;;
13647 *darwin*)
13648 VAR_OS=macosx
13649 VAR_OS_TYPE=unix
13650 ;;
13651 *bsd*)
13652 VAR_OS=bsd
13653 VAR_OS_TYPE=unix
13654 ;;
13655 *cygwin*)
13656 VAR_OS=windows
13657 VAR_OS_ENV=windows.cygwin
13658 ;;
13659 *mingw*)
13660 VAR_OS=windows
13661 VAR_OS_ENV=windows.msys
13662 ;;
13663 *aix*)
13664 VAR_OS=aix
13665 VAR_OS_TYPE=unix
13666 ;;
13667 *)
13668 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13669 ;;
13670 esac
13671
13672
13673 # First argument is the cpu name from the trip/quad
13674 case "$build_cpu" in
13675 x86_64)
13676 VAR_CPU=x86_64
13677 VAR_CPU_ARCH=x86
13678 VAR_CPU_BITS=64
13679 VAR_CPU_ENDIAN=little
13680 ;;
13681 i?86)
13682 VAR_CPU=x86
13683 VAR_CPU_ARCH=x86
13684 VAR_CPU_BITS=32
13685 VAR_CPU_ENDIAN=little
13686 ;;
13687 arm*)
13688 VAR_CPU=arm
13689 VAR_CPU_ARCH=arm
13690 VAR_CPU_BITS=32
13691 VAR_CPU_ENDIAN=little
13692 ;;
13693 aarch64)
13694 VAR_CPU=aarch64
13695 VAR_CPU_ARCH=aarch64
13696 VAR_CPU_BITS=64
13697 VAR_CPU_ENDIAN=little
13698 ;;
13699 powerpc)
13700 VAR_CPU=ppc
13701 VAR_CPU_ARCH=ppc
13702 VAR_CPU_BITS=32
13703 VAR_CPU_ENDIAN=big
13704 ;;
13705 powerpc64)
13706 VAR_CPU=ppc64
13707 VAR_CPU_ARCH=ppc
13708 VAR_CPU_BITS=64
13709 VAR_CPU_ENDIAN=big
13710 ;;
13711 powerpc64le)
13712 VAR_CPU=ppc64
13713 VAR_CPU_ARCH=ppc
13714 VAR_CPU_BITS=64
13715 VAR_CPU_ENDIAN=little
13716 ;;
13717 s390)
13718 VAR_CPU=s390
13719 VAR_CPU_ARCH=s390
13720 VAR_CPU_BITS=32
13721 VAR_CPU_ENDIAN=big
13722 ;;
13723 s390x)
13724 VAR_CPU=s390x
13725 VAR_CPU_ARCH=s390
13726 VAR_CPU_BITS=64
13727 VAR_CPU_ENDIAN=big
13728 ;;
13729 sparc)
13730 VAR_CPU=sparc
13731 VAR_CPU_ARCH=sparc
13732 VAR_CPU_BITS=32
13733 VAR_CPU_ENDIAN=big
13734 ;;
13735 sparcv9|sparc64)
13736 VAR_CPU=sparcv9
13737 VAR_CPU_ARCH=sparc
13738 VAR_CPU_BITS=64
13739 VAR_CPU_ENDIAN=big
13740 ;;
13741 *)
13742 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13743 ;;
13744 esac
13745
13746 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13747 OPENJDK_BUILD_OS="$VAR_OS"
13748 if test "x$VAR_OS_TYPE" != x; then
13749 OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13750 else
13751 OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13752 fi
13753 if test "x$VAR_OS_ENV" != x; then
13754 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13755 else
13756 OPENJDK_BUILD_OS_ENV="$VAR_OS"
13757 fi
13758 OPENJDK_BUILD_CPU="$VAR_CPU"
13759 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13760 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13761 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13762
13763
13764
13765
13766
13767
13768
13769
13770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13771 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13772 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13773 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13774
13775 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13776
13777 case "$host_os" in
13778 *linux*)
13779 VAR_OS=linux
13780 VAR_OS_TYPE=unix
13781 ;;
13782 *solaris*)
13783 VAR_OS=solaris
13784 VAR_OS_TYPE=unix
13785 ;;
13786 *darwin*)
13787 VAR_OS=macosx
13788 VAR_OS_TYPE=unix
13789 ;;
13790 *bsd*)
13791 VAR_OS=bsd
13792 VAR_OS_TYPE=unix
13793 ;;
13794 *cygwin*)
13795 VAR_OS=windows
13796 VAR_OS_ENV=windows.cygwin
13797 ;;
13798 *mingw*)
13799 VAR_OS=windows
13800 VAR_OS_ENV=windows.msys
13801 ;;
13802 *aix*)
13803 VAR_OS=aix
13804 VAR_OS_TYPE=unix
13805 ;;
13806 *)
13807 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13808 ;;
13809 esac
13810
13811
13812 # First argument is the cpu name from the trip/quad
13813 case "$host_cpu" in
13814 x86_64)
13815 VAR_CPU=x86_64
13816 VAR_CPU_ARCH=x86
13817 VAR_CPU_BITS=64
13818 VAR_CPU_ENDIAN=little
13819 ;;
13820 i?86)
13821 VAR_CPU=x86
13822 VAR_CPU_ARCH=x86
13823 VAR_CPU_BITS=32
13824 VAR_CPU_ENDIAN=little
13825 ;;
13826 arm*)
13827 VAR_CPU=arm
13828 VAR_CPU_ARCH=arm
13829 VAR_CPU_BITS=32
13830 VAR_CPU_ENDIAN=little
13831 ;;
13832 aarch64)
13833 VAR_CPU=aarch64
13834 VAR_CPU_ARCH=aarch64
13835 VAR_CPU_BITS=64
13836 VAR_CPU_ENDIAN=little
13837 ;;
13838 powerpc)
13839 VAR_CPU=ppc
13840 VAR_CPU_ARCH=ppc
13841 VAR_CPU_BITS=32
13842 VAR_CPU_ENDIAN=big
13843 ;;
13844 powerpc64)
13845 VAR_CPU=ppc64
13846 VAR_CPU_ARCH=ppc
13847 VAR_CPU_BITS=64
13848 VAR_CPU_ENDIAN=big
13849 ;;
13850 powerpc64le)
13851 VAR_CPU=ppc64
13852 VAR_CPU_ARCH=ppc
13853 VAR_CPU_BITS=64
13854 VAR_CPU_ENDIAN=little
13855 ;;
13856 s390)
13857 VAR_CPU=s390
13858 VAR_CPU_ARCH=s390
13859 VAR_CPU_BITS=32
13860 VAR_CPU_ENDIAN=big
13861 ;;
13862 s390x)
13863 VAR_CPU=s390x
13864 VAR_CPU_ARCH=s390
13865 VAR_CPU_BITS=64
13866 VAR_CPU_ENDIAN=big
13867 ;;
13868 sparc)
13869 VAR_CPU=sparc
13870 VAR_CPU_ARCH=sparc
13871 VAR_CPU_BITS=32
13872 VAR_CPU_ENDIAN=big
13873 ;;
13874 sparcv9|sparc64)
13875 VAR_CPU=sparcv9
13876 VAR_CPU_ARCH=sparc
13877 VAR_CPU_BITS=64
13878 VAR_CPU_ENDIAN=big
13879 ;;
13880 *)
13881 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13882 ;;
13883 esac
13884
13885 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13886 OPENJDK_TARGET_OS="$VAR_OS"
13887 if test "x$VAR_OS_TYPE" != x; then
13888 OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13889 else
13890 OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13891 fi
13892 if test "x$VAR_OS_ENV" != x; then
13893 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13894 else
13895 OPENJDK_TARGET_OS_ENV="$VAR_OS"
13896 fi
13897 OPENJDK_TARGET_CPU="$VAR_CPU"
13898 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13899 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13900 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13901
13902
13903
13904
13905
13906
13907
13908
13909 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13910 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13912 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13913
13914
13915
13916 # Check whether --with-target-bits was given.
13917 if test "${with_target_bits+set}" = set; then :
13918 withval=$with_target_bits;
13919 fi
13920
13921
13922 # We have three types of compiles:
13923 # native == normal compilation, target system == build system
13924 # cross == traditional cross compilation, target system != build system; special toolchain needed
13925 # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13926 #
13927 if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13928 # We're doing a proper cross-compilation
13929 COMPILE_TYPE="cross"
13930 else
13931 COMPILE_TYPE="native"
13932 fi
13933
13934 if test "x$with_target_bits" != x; then
13935 if test "x$COMPILE_TYPE" = "xcross"; then
13936 as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13937 fi
13938
13939 if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13940 # A reduced build is requested
13941 COMPILE_TYPE="reduced"
13942 OPENJDK_TARGET_CPU_BITS=32
13943 if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13944 OPENJDK_TARGET_CPU=x86
13945 elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13946 OPENJDK_TARGET_CPU=sparc
13947 else
13948 as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13949 fi
13950 elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13951 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
13952 elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13953 { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13954 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13955 else
13956 as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13957 fi
13958 fi
13959
13960
13961 { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13962 $as_echo_n "checking compilation type... " >&6; }
13963 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13964 $as_echo "$COMPILE_TYPE" >&6; }
13965
13966
13967 if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13968 REQUIRED_OS_NAME=SunOS
13969 REQUIRED_OS_VERSION=5.10
13970 fi
13971 if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13972 REQUIRED_OS_NAME=Linux
13973 REQUIRED_OS_VERSION=2.6
13974 fi
13975 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13976 REQUIRED_OS_NAME=Windows
13977 if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13978 REQUIRED_OS_VERSION=5.2
13979 else
13980 REQUIRED_OS_VERSION=5.1
13981 fi
13982 fi
13983 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13984 REQUIRED_OS_NAME=Darwin
13985 REQUIRED_OS_VERSION=11.2
13986 fi
13987
13988
13989
13990
13991
13992 # Also store the legacy naming of the cpu.
13993 # Ie i586 and amd64 instead of x86 and x86_64
13994 OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13995 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13996 OPENJDK_TARGET_CPU_LEGACY="i586"
13997 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13998 # On all platforms except MacOSX replace x86_64 with amd64.
13999 OPENJDK_TARGET_CPU_LEGACY="amd64"
14000 fi
14001
14002
14003 # And the second legacy naming of the cpu.
14004 # Ie i386 and amd64 instead of x86 and x86_64.
14005 OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
14006 if test "x$OPENJDK_TARGET_CPU" = xx86; then
14007 OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
14008 elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14009 OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
14010 fi
14011
14012
14013 # This is the name of the cpu (but using i386 and amd64 instead of
14014 # x86 and x86_64, respectively), preceeded by a /, to be used when
14015 # locating libraries. On macosx, it's empty, though.
14016 OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
14017 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14018 OPENJDK_TARGET_CPU_LIBDIR=""
14019 fi
14020
14021
14022 # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
14023 # /amd64 or /sparcv9. This string is appended to some library paths, like this:
14024 # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
14025 OPENJDK_TARGET_CPU_ISADIR=""
14026 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
14027 if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14028 OPENJDK_TARGET_CPU_ISADIR="/amd64"
14029 elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
14030 OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
14031 fi
14032 fi
14033
14034
14035 # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
14036 OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
14037 if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
14038 # On linux only, we replace x86 with i386.
14039 OPENJDK_TARGET_CPU_OSARCH="i386"
14040 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14041 # On all platforms except macosx, we replace x86_64 with amd64.
14042 OPENJDK_TARGET_CPU_OSARCH="amd64"
14043 fi
14044
14045
14046 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
14047 if test "x$OPENJDK_TARGET_CPU" = xx86; then
14048 OPENJDK_TARGET_CPU_JLI="i386"
14049 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14050 # On all platforms except macosx, we replace x86_64 with amd64.
14051 OPENJDK_TARGET_CPU_JLI="amd64"
14052 fi
14053 # Now setup the -D flags for building libjli.
14054 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
14055 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
14056 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
14057 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
14058 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
14059 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
14060 fi
14061 fi
14062
14063
14064 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14065 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
14066 else
14067 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
14068 fi
14069
14070
14071 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14072 A_LP64="LP64:="
14073 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
14074 # unpack200.exe
14075 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
14076 ADD_LP64="-D_LP64=1"
14077 fi
14078 fi
14079 LP64=$A_LP64
14080
14081
14082 if test "x$COMPILE_TYPE" = "xcross"; then
14083 # FIXME: ... or should this include reduced builds..?
14084 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
14085 else
14086 DEFINE_CROSS_COMPILE_ARCH=""
14087 fi
14088
14089
14090 # ZERO_ARCHDEF is used to enable architecture-specific code
14091 case "${OPENJDK_TARGET_CPU}" in
14092 ppc) ZERO_ARCHDEF=PPC32 ;;
14093 ppc64) ZERO_ARCHDEF=PPC64 ;;
14094 s390*) ZERO_ARCHDEF=S390 ;;
14095 sparc*) ZERO_ARCHDEF=SPARC ;;
14096 x86_64*) ZERO_ARCHDEF=AMD64 ;;
14097 x86) ZERO_ARCHDEF=IA32 ;;
14098 *) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14099 esac
14100
14101
14102
14103
14104 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14105
14106 # Save the current directory this script was started from
14107 CURDIR="$PWD"
14108
14109 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14110 PATH_SEP=";"
14111
14112 SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14113 if test $SRC_ROOT_LENGTH -gt 100; then
14114 as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14115 fi
14116
14117 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14118 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14119 $as_echo_n "checking cygwin release... " >&6; }
14120 CYGWIN_VERSION=`$UNAME -r`
14121 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14122 $as_echo "$CYGWIN_VERSION" >&6; }
14123 WINDOWS_ENV_VENDOR='cygwin'
14124 WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14125
14126 CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
14127 if test "x$CYGWIN_VERSION_OLD" != x; then
14128 { $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
14129 $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;}
14130 as_fn_error $? "Cannot continue" "$LINENO" 5
14131 fi
14132 if test "x$CYGPATH" = x; then
14133 as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14134 fi
14135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14136 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14137 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14138 cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
14139 # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14140 CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14141 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14142 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14143 WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14144 test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14145 if test "x$test_cygdrive_prefix" = x; then
14146 as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14147 fi
14148 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14150 $as_echo_n "checking msys release... " >&6; }
14151 MSYS_VERSION=`$UNAME -r`
14152 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14153 $as_echo "$MSYS_VERSION" >&6; }
14154
14155 WINDOWS_ENV_VENDOR='msys'
14156 WINDOWS_ENV_VERSION="$MSYS_VERSION"
14157
14158 { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14159 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14160 # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14161 MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14162
14163 windows_path="$MSYS_ROOT_PATH"
14164 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14165 unix_path=`$CYGPATH -u "$windows_path"`
14166 MSYS_ROOT_PATH="$unix_path"
14167 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14168 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14169 MSYS_ROOT_PATH="$unix_path"
14170 fi
14171
14172 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14173 $as_echo "$MSYS_ROOT_PATH" >&6; }
14174 WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14175 else
14176 as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14177 fi
14178
14179 # Test if windows or unix (cygwin/msys) find is first in path.
14180 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14181 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14182 FIND_BINARY_OUTPUT=`find --version 2>&1`
14183 if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14185 $as_echo "unix style" >&6; }
14186 elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14187 { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14188 $as_echo "Windows" >&6; }
14189 { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14190 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14191 { $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
14192 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14193 as_fn_error $? "Cannot continue" "$LINENO" 5
14194 else
14195 { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14196 $as_echo "unknown" >&6; }
14197 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14198 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14199 fi
14200
14201 else
14202 PATH_SEP=":"
14203 fi
14204
14205
14206 # We get the top-level directory from the supporting wrappers.
14207 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14208 $as_echo_n "checking for top-level directory... " >&6; }
14209 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14210 $as_echo "$TOPDIR" >&6; }
14211
14212
14213 # Save the original version of TOPDIR for string comparisons
14214 ORIGINAL_TOPDIR="$TOPDIR"
14215
14216
14217 # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14218
14219 # Only process if variable expands to non-empty
14220
14221 if test "x$CURDIR" != x; then
14222 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14223
14224 # Input might be given as Windows format, start by converting to
14225 # unix format.
14226 path="$CURDIR"
14227 new_path=`$CYGPATH -u "$path"`
14228
14229 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14230 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14231 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14232 # "foo.exe" is OK but "foo" is an error.
14233 #
14234 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14235 # It is also a way to make sure we got the proper file name for the real test later on.
14236 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14237 if test "x$test_shortpath" = x; then
14238 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14239 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14240 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14241 fi
14242
14243 # Call helper function which possibly converts this using DOS-style short mode.
14244 # If so, the updated path is stored in $new_path.
14245
14246 input_path="$new_path"
14247 # Check if we need to convert this using DOS-style short mode. If the path
14248 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14249 # take no chances and rewrite it.
14250 # Note: m4 eats our [], so we need to use [ and ] instead.
14251 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14252 if test "x$has_forbidden_chars" != x; then
14253 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14254 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14255 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14256 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14257 # Going to short mode and back again did indeed matter. Since short mode is
14258 # case insensitive, let's make it lowercase to improve readability.
14259 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14260 # Now convert it back to Unix-style (cygpath)
14261 input_path=`$CYGPATH -u "$shortmode_path"`
14262 new_path="$input_path"
14263 fi
14264 fi
14265
14266 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14267 if test "x$test_cygdrive_prefix" = x; then
14268 # As a simple fix, exclude /usr/bin since it's not a real path.
14269 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14270 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14271 # a path prefixed by /cygdrive for fixpath to work.
14272 new_path="$CYGWIN_ROOT_PATH$input_path"
14273 fi
14274 fi
14275
14276
14277 if test "x$path" != "x$new_path"; then
14278 CURDIR="$new_path"
14279 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14280 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14281 fi
14282
14283 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14284
14285 path="$CURDIR"
14286 has_colon=`$ECHO $path | $GREP ^.:`
14287 new_path="$path"
14288 if test "x$has_colon" = x; then
14289 # Not in mixed or Windows style, start by that.
14290 new_path=`cmd //c echo $path`
14291 fi
14292
14293
14294 input_path="$new_path"
14295 # Check if we need to convert this using DOS-style short mode. If the path
14296 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14297 # take no chances and rewrite it.
14298 # Note: m4 eats our [], so we need to use [ and ] instead.
14299 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14300 if test "x$has_forbidden_chars" != x; then
14301 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14302 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14303 fi
14304
14305
14306 windows_path="$new_path"
14307 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14308 unix_path=`$CYGPATH -u "$windows_path"`
14309 new_path="$unix_path"
14310 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14311 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14312 new_path="$unix_path"
14313 fi
14314
14315 if test "x$path" != "x$new_path"; then
14316 CURDIR="$new_path"
14317 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14318 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14319 fi
14320
14321 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14322 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14323
14324 else
14325 # We're on a unix platform. Hooray! :)
14326 path="$CURDIR"
14327 has_space=`$ECHO "$path" | $GREP " "`
14328 if test "x$has_space" != x; then
14329 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14330 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14331 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14332 fi
14333
14334 # Use eval to expand a potential ~
14335 eval path="$path"
14336 if test ! -f "$path" && test ! -d "$path"; then
14337 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14338 fi
14339
14340 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14341 fi
14342 fi
14343
14344
14345 # Only process if variable expands to non-empty
14346
14347 if test "x$TOPDIR" != x; then
14348 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14349
14350 # Input might be given as Windows format, start by converting to
14351 # unix format.
14352 path="$TOPDIR"
14353 new_path=`$CYGPATH -u "$path"`
14354
14355 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14356 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14357 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14358 # "foo.exe" is OK but "foo" is an error.
14359 #
14360 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14361 # It is also a way to make sure we got the proper file name for the real test later on.
14362 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14363 if test "x$test_shortpath" = x; then
14364 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14365 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14366 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14367 fi
14368
14369 # Call helper function which possibly converts this using DOS-style short mode.
14370 # If so, the updated path is stored in $new_path.
14371
14372 input_path="$new_path"
14373 # Check if we need to convert this using DOS-style short mode. If the path
14374 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14375 # take no chances and rewrite it.
14376 # Note: m4 eats our [], so we need to use [ and ] instead.
14377 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14378 if test "x$has_forbidden_chars" != x; then
14379 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14380 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14381 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14382 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14383 # Going to short mode and back again did indeed matter. Since short mode is
14384 # case insensitive, let's make it lowercase to improve readability.
14385 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14386 # Now convert it back to Unix-style (cygpath)
14387 input_path=`$CYGPATH -u "$shortmode_path"`
14388 new_path="$input_path"
14389 fi
14390 fi
14391
14392 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14393 if test "x$test_cygdrive_prefix" = x; then
14394 # As a simple fix, exclude /usr/bin since it's not a real path.
14395 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14396 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14397 # a path prefixed by /cygdrive for fixpath to work.
14398 new_path="$CYGWIN_ROOT_PATH$input_path"
14399 fi
14400 fi
14401
14402
14403 if test "x$path" != "x$new_path"; then
14404 TOPDIR="$new_path"
14405 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14406 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14407 fi
14408
14409 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14410
14411 path="$TOPDIR"
14412 has_colon=`$ECHO $path | $GREP ^.:`
14413 new_path="$path"
14414 if test "x$has_colon" = x; then
14415 # Not in mixed or Windows style, start by that.
14416 new_path=`cmd //c echo $path`
14417 fi
14418
14419
14420 input_path="$new_path"
14421 # Check if we need to convert this using DOS-style short mode. If the path
14422 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14423 # take no chances and rewrite it.
14424 # Note: m4 eats our [], so we need to use [ and ] instead.
14425 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14426 if test "x$has_forbidden_chars" != x; then
14427 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14428 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14429 fi
14430
14431
14432 windows_path="$new_path"
14433 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14434 unix_path=`$CYGPATH -u "$windows_path"`
14435 new_path="$unix_path"
14436 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14437 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14438 new_path="$unix_path"
14439 fi
14440
14441 if test "x$path" != "x$new_path"; then
14442 TOPDIR="$new_path"
14443 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14444 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14445 fi
14446
14447 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14448 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14449
14450 else
14451 # We're on a unix platform. Hooray! :)
14452 path="$TOPDIR"
14453 has_space=`$ECHO "$path" | $GREP " "`
14454 if test "x$has_space" != x; then
14455 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14456 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14457 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14458 fi
14459
14460 # Use eval to expand a potential ~
14461 eval path="$path"
14462 if test ! -f "$path" && test ! -d "$path"; then
14463 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14464 fi
14465
14466 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14467 fi
14468 fi
14469
14470 # SRC_ROOT is a traditional alias for TOPDIR.
14471 SRC_ROOT=$TOPDIR
14472
14473 # Calculate a canonical version of TOPDIR for string comparisons
14474 CANONICAL_TOPDIR=$TOPDIR
14475
14476 if test "x$OPENJDK_BUILD_OS" != xwindows; then
14477 # Follow a chain of symbolic links. Use readlink
14478 # where it exists, else fall back to horribly
14479 # complicated shell code.
14480 if test "x$READLINK_TESTED" != yes; then
14481 # On MacOSX there is a readlink tool with a different
14482 # purpose than the GNU readlink tool. Check the found readlink.
14483 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
14484 if test "x$ISGNU" = x; then
14485 # A readlink that we do not know how to use.
14486 # Are there other non-GNU readlinks out there?
14487 READLINK_TESTED=yes
14488 READLINK=
14489 fi
14490 fi
14491
14492 if test "x$READLINK" != x; then
14493 CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
14494 else
14495 # Save the current directory for restoring afterwards
14496 STARTDIR=$PWD
14497 COUNTER=0
14498 sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
14499 sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
14500 cd $sym_link_dir
14501 # Use -P flag to resolve symlinks in directories.
14502 cd `$THEPWDCMD -P`
14503 sym_link_dir=`$THEPWDCMD -P`
14504 # Resolve file symlinks
14505 while test $COUNTER -lt 20; do
14506 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
14507 if test "x$ISLINK" == x; then
14508 # This is not a symbolic link! We are done!
14509 break
14510 fi
14511 # Again resolve directory symlinks since the target of the just found
14512 # link could be in a different directory
14513 cd `$DIRNAME $ISLINK`
14514 sym_link_dir=`$THEPWDCMD -P`
14515 sym_link_file=`$BASENAME $ISLINK`
14516 let COUNTER=COUNTER+1
14517 done
14518 cd $STARTDIR
14519 CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
14520 fi
14521 fi
14522
14523
14524
14525 # Locate the directory of this script.
14526 AUTOCONF_DIR=$TOPDIR/common/autoconf
14527
14528
14529 # Check if it's a pure open build or if custom sources are to be used.
14530
14531 # Check whether --enable-openjdk-only was given.
14532 if test "${enable_openjdk_only+set}" = set; then :
14533 enableval=$enable_openjdk_only;
14534 else
14535 enable_openjdk_only="no"
14536 fi
14537
14538
14539 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14540 $as_echo_n "checking for presence of closed sources... " >&6; }
14541 if test -d "$SRC_ROOT/jdk/src/closed"; then
14542 CLOSED_SOURCE_PRESENT=yes
14543 else
14544 CLOSED_SOURCE_PRESENT=no
14545 fi
14546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14547 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14548
14549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14550 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14551 SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14553 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14554
14555 if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14556 OPENJDK=true
14557 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14558 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14559 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14560 fi
14561 else
14562 if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14563 OPENJDK=true
14564 else
14565 OPENJDK=false
14566 fi
14567 fi
14568
14569 if test "x$OPENJDK" = "xtrue"; then
14570 SET_OPENJDK="OPENJDK=true"
14571 fi
14572
14573
14574
14575 # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14576 # the IncludeCustomExtension macro.
14577
14578
14579 # Check whether --with-custom-make-dir was given.
14580 if test "${with_custom_make_dir+set}" = set; then :
14581 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
14582 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14583 fi
14584
14585
14586
14587
14588 # These are needed to be able to create a configuration name (and thus the output directory)
14589
14590 ###############################################################################
14591 #
14592 # Check which variant of the JDK that we want to build.
14593 # Currently we have:
14594 # normal: standard edition
14595 # but the custom make system may add other variants
14596 #
14597 # Effectively the JDK variant gives a name to a specific set of
14598 # modules to compile into the JDK. In the future, these modules
14599 # might even be Jigsaw modules.
14600 #
14601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14602 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14603
14604 # Check whether --with-jdk-variant was given.
14605 if test "${with_jdk_variant+set}" = set; then :
14606 withval=$with_jdk_variant;
14607 fi
14608
14609
14610 if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14611 JDK_VARIANT="normal"
14612 else
14613 as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14614 fi
14615
14616
14617
14618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14619 $as_echo "$JDK_VARIANT" >&6; }
14620
14621
14622 ###############################################################################
14623 #
14624 # Check which interpreter of the JVM we want to build.
14625 # Currently we have:
14626 # template: Template interpreter (the default)
14627 # cpp : C++ interpreter
14628 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14629 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14630
14631 # Check whether --with-jvm-interpreter was given.
14632 if test "${with_jvm_interpreter+set}" = set; then :
14633 withval=$with_jvm_interpreter;
14634 fi
14635
14636
14637 if test "x$with_jvm_interpreter" = x; then
14638 with_jvm_interpreter="template"
14639 fi
14640
14641 JVM_INTERPRETER="$with_jvm_interpreter"
14642
14643 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14644 as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14645 fi
14646
14647
14648
14649 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14650 $as_echo "$with_jvm_interpreter" >&6; }
14651
14652
14653
14654 ###############################################################################
14655 #
14656 # Check which variants of the JVM that we want to build.
14657 # Currently we have:
14658 # server: normal interpreter and a tiered C1/C2 compiler
14659 # client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14660 # minimal1: reduced form of client with optional VM services and features stripped out
14661 # kernel: kernel footprint JVM that passes the TCK without major performance problems,
14662 # ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14663 # zero: no machine code interpreter, no compiler
14664 # zeroshark: zero interpreter and shark/llvm compiler backend
14665 # core: interpreter only, no compiler (only works on some platforms)
14666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14667 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14668
14669 # Check whether --with-jvm-variants was given.
14670 if test "${with_jvm_variants+set}" = set; then :
14671 withval=$with_jvm_variants;
14672 fi
14673
14674
14675 if test "x$with_jvm_variants" = x; then
14676 with_jvm_variants="server"
14677 fi
14678
14679 JVM_VARIANTS=",$with_jvm_variants,"
14680 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,//'`
14681
14682 if test "x$TEST_VARIANTS" != "x,"; then
14683 as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14684 fi
14685 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14686 $as_echo "$with_jvm_variants" >&6; }
14687
14688 JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14689 JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14690 JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14691 JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14692 JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14693 JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14694 JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14695
14696 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14697 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14698 as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14699 fi
14700 fi
14701 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14702 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14703 as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14704 fi
14705 fi
14706 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14707 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14708 as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14709 fi
14710 fi
14711
14712 # Replace the commas with AND for use in the build directory name.
14713 ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14714 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/'`
14715 if test "x$COUNT_VARIANTS" != "x,1"; then
14716 BUILDING_MULTIPLE_JVM_VARIANTS=yes
14717 else
14718 BUILDING_MULTIPLE_JVM_VARIANTS=no
14719 fi
14720
14721
14722
14723
14724
14725
14726
14727
14728
14729
14730 INCLUDE_SA=true
14731 if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14732 INCLUDE_SA=false
14733 fi
14734 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14735 INCLUDE_SA=false
14736 fi
14737 if test "x$OPENJDK_TARGET_OS" = xaix ; then
14738 INCLUDE_SA=false
14739 fi
14740 if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14741 INCLUDE_SA=false
14742 fi
14743
14744
14745 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14746 MACOSX_UNIVERSAL="true"
14747 fi
14748
14749
14750
14751
14752 ###############################################################################
14753 #
14754 # Set the debug level
14755 # release: no debug information, all optimizations, no asserts.
14756 # optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14757 # fastdebug: debug information (-g), all optimizations, all asserts
14758 # slowdebug: debug information (-g), no optimizations, all asserts
14759 #
14760 DEBUG_LEVEL="release"
14761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14762 $as_echo_n "checking which debug level to use... " >&6; }
14763 # Check whether --enable-debug was given.
14764 if test "${enable_debug+set}" = set; then :
14765 enableval=$enable_debug;
14766 ENABLE_DEBUG="${enableval}"
14767 DEBUG_LEVEL="fastdebug"
14768
14769 else
14770 ENABLE_DEBUG="no"
14771 fi
14772
14773
14774
14775 # Check whether --with-debug-level was given.
14776 if test "${with_debug_level+set}" = set; then :
14777 withval=$with_debug_level;
14778 DEBUG_LEVEL="${withval}"
14779 if test "x$ENABLE_DEBUG" = xyes; then
14780 as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14781 fi
14782
14783 fi
14784
14785 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14786 $as_echo "$DEBUG_LEVEL" >&6; }
14787
14788 if test "x$DEBUG_LEVEL" != xrelease && \
14789 test "x$DEBUG_LEVEL" != xoptimized && \
14790 test "x$DEBUG_LEVEL" != xfastdebug && \
14791 test "x$DEBUG_LEVEL" != xslowdebug; then
14792 as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14793 fi
14794
14795
14796 ###############################################################################
14797 #
14798 # Setup legacy vars/targets and new vars to deal with different debug levels.
14799 #
14800
14801 case $DEBUG_LEVEL in
14802 release )
14803 VARIANT="OPT"
14804 FASTDEBUG="false"
14805 DEBUG_CLASSFILES="false"
14806 BUILD_VARIANT_RELEASE=""
14807 HOTSPOT_DEBUG_LEVEL="product"
14808 HOTSPOT_EXPORT="product"
14809 ;;
14810 fastdebug )
14811 VARIANT="DBG"
14812 FASTDEBUG="true"
14813 DEBUG_CLASSFILES="true"
14814 BUILD_VARIANT_RELEASE="-fastdebug"
14815 HOTSPOT_DEBUG_LEVEL="fastdebug"
14816 HOTSPOT_EXPORT="fastdebug"
14817 ;;
14818 slowdebug )
14819 VARIANT="DBG"
14820 FASTDEBUG="false"
14821 DEBUG_CLASSFILES="true"
14822 BUILD_VARIANT_RELEASE="-debug"
14823 HOTSPOT_DEBUG_LEVEL="debug"
14824 HOTSPOT_EXPORT="debug"
14825 ;;
14826 optimized )
14827 VARIANT="OPT"
14828 FASTDEBUG="false"
14829 DEBUG_CLASSFILES="false"
14830 BUILD_VARIANT_RELEASE="-optimized"
14831 HOTSPOT_DEBUG_LEVEL="optimized"
14832 HOTSPOT_EXPORT="optimized"
14833 ;;
14834 esac
14835
14836 # The debug level 'optimized' is a little special because it is currently only
14837 # applicable to the HotSpot build where it means to build a completely
14838 # optimized version of the VM without any debugging code (like for the
14839 # 'release' debug level which is called 'product' in the HotSpot build) but
14840 # with the exception that it can contain additional code which is otherwise
14841 # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14842 # test new and/or experimental features which are not intended for customer
14843 # shipment. Because these new features need to be tested and benchmarked in
14844 # real world scenarios, we want to build the containing JDK at the 'release'
14845 # debug level.
14846 if test "x$DEBUG_LEVEL" = xoptimized; then
14847 DEBUG_LEVEL="release"
14848 fi
14849
14850 #####
14851 # Generate the legacy makefile targets for hotspot.
14852 # The hotspot api for selecting the build artifacts, really, needs to be improved.
14853 # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14854 # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14855 # But until then ...
14856 HOTSPOT_TARGET=""
14857
14858 if test "x$JVM_VARIANT_SERVER" = xtrue; then
14859 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14860 fi
14861
14862 if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14863 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14864 fi
14865
14866 if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14867 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14868 fi
14869
14870 if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14871 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14872 fi
14873
14874 if test "x$JVM_VARIANT_ZERO" = xtrue; then
14875 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14876 fi
14877
14878 if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14879 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14880 fi
14881
14882 if test "x$JVM_VARIANT_CORE" = xtrue; then
14883 HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14884 fi
14885
14886 HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14887
14888 # On Macosx universal binaries are produced, but they only contain
14889 # 64 bit intel. This invalidates control of which jvms are built
14890 # from configure, but only server is valid anyway. Fix this
14891 # when hotspot makefiles are rewritten.
14892 if test "x$MACOSX_UNIVERSAL" = xtrue; then
14893 HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14894 fi
14895
14896 #####
14897
14898
14899
14900
14901
14902
14903
14904
14905 # With basic setup done, call the custom early hook.
14906
14907
14908 # Check if we have devkits, extra paths or sysroot set.
14909
14910
14911 # Check whether --with-devkit was given.
14912 if test "${with_devkit+set}" = set; then :
14913 withval=$with_devkit;
14914
14915 # Only process if variable expands to non-empty
14916
14917 if test "x$with_devkit" != x; then
14918 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14919
14920 # Input might be given as Windows format, start by converting to
14921 # unix format.
14922 path="$with_devkit"
14923 new_path=`$CYGPATH -u "$path"`
14924
14925 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14926 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14927 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14928 # "foo.exe" is OK but "foo" is an error.
14929 #
14930 # This test is therefore slightly more accurate than "test -f" to check for file precense.
14931 # It is also a way to make sure we got the proper file name for the real test later on.
14932 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14933 if test "x$test_shortpath" = x; then
14934 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14935 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14936 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14937 fi
14938
14939 # Call helper function which possibly converts this using DOS-style short mode.
14940 # If so, the updated path is stored in $new_path.
14941
14942 input_path="$new_path"
14943 # Check if we need to convert this using DOS-style short mode. If the path
14944 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14945 # take no chances and rewrite it.
14946 # Note: m4 eats our [], so we need to use [ and ] instead.
14947 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14948 if test "x$has_forbidden_chars" != x; then
14949 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14950 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14951 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14952 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14953 # Going to short mode and back again did indeed matter. Since short mode is
14954 # case insensitive, let's make it lowercase to improve readability.
14955 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14956 # Now convert it back to Unix-style (cygpath)
14957 input_path=`$CYGPATH -u "$shortmode_path"`
14958 new_path="$input_path"
14959 fi
14960 fi
14961
14962 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14963 if test "x$test_cygdrive_prefix" = x; then
14964 # As a simple fix, exclude /usr/bin since it's not a real path.
14965 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14966 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14967 # a path prefixed by /cygdrive for fixpath to work.
14968 new_path="$CYGWIN_ROOT_PATH$input_path"
14969 fi
14970 fi
14971
14972
14973 if test "x$path" != "x$new_path"; then
14974 with_devkit="$new_path"
14975 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14976 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14977 fi
14978
14979 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14980
14981 path="$with_devkit"
14982 has_colon=`$ECHO $path | $GREP ^.:`
14983 new_path="$path"
14984 if test "x$has_colon" = x; then
14985 # Not in mixed or Windows style, start by that.
14986 new_path=`cmd //c echo $path`
14987 fi
14988
14989
14990 input_path="$new_path"
14991 # Check if we need to convert this using DOS-style short mode. If the path
14992 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14993 # take no chances and rewrite it.
14994 # Note: m4 eats our [], so we need to use [ and ] instead.
14995 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14996 if test "x$has_forbidden_chars" != x; then
14997 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14998 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14999 fi
15000
15001
15002 windows_path="$new_path"
15003 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15004 unix_path=`$CYGPATH -u "$windows_path"`
15005 new_path="$unix_path"
15006 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15007 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15008 new_path="$unix_path"
15009 fi
15010
15011 if test "x$path" != "x$new_path"; then
15012 with_devkit="$new_path"
15013 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
15014 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
15015 fi
15016
15017 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15018 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15019
15020 else
15021 # We're on a unix platform. Hooray! :)
15022 path="$with_devkit"
15023 has_space=`$ECHO "$path" | $GREP " "`
15024 if test "x$has_space" != x; then
15025 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
15026 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
15027 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15028 fi
15029
15030 # Use eval to expand a potential ~
15031 eval path="$path"
15032 if test ! -f "$path" && test ! -d "$path"; then
15033 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
15034 fi
15035
15036 with_devkit="`cd "$path"; $THEPWDCMD -L`"
15037 fi
15038 fi
15039
15040 DEVKIT_ROOT="$with_devkit"
15041 # Check for a meta data info file in the root of the devkit
15042 if test -f "$DEVKIT_ROOT/devkit.info"; then
15043 . $DEVKIT_ROOT/devkit.info
15044 # This potentially sets the following:
15045 # A descriptive name of the devkit
15046
15047 if test "x$DEVKIT_NAME" = x; then
15048 eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
15049 fi
15050
15051 # Corresponds to --with-extra-path
15052
15053 if test "x$DEVKIT_EXTRA_PATH" = x; then
15054 eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
15055 fi
15056
15057 # Corresponds to --with-toolchain-path
15058
15059 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
15060 eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
15061 fi
15062
15063 # Corresponds to --with-sysroot
15064
15065 if test "x$DEVKIT_SYSROOT" = x; then
15066 eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
15067 fi
15068
15069
15070 # Identifies the Visual Studio version in the devkit
15071
15072 if test "x$DEVKIT_VS_VERSION" = x; then
15073 eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
15074 fi
15075
15076 # The Visual Studio include environment variable
15077
15078 if test "x$DEVKIT_VS_INCLUDE" = x; then
15079 eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
15080 fi
15081
15082 # The Visual Studio lib environment variable
15083
15084 if test "x$DEVKIT_VS_LIB" = x; then
15085 eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
15086 fi
15087
15088 # Corresponds to --with-msvcr-dll
15089
15090 if test "x$DEVKIT_MSVCR_DLL" = x; then
15091 eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
15092 fi
15093
15094 # Corresponds to --with-msvcp-dll
15095
15096 if test "x$DEVKIT_MSVCP_DLL" = x; then
15097 eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
15098 fi
15099
15100 fi
15101
15102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
15103 $as_echo_n "checking for devkit... " >&6; }
15104 if test "x$DEVKIT_NAME" != x; then
15105 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
15106 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
15107 else
15108 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
15109 $as_echo "$DEVKIT_ROOT" >&6; }
15110 fi
15111
15112
15113 if test "x$DEVKIT_EXTRA_PATH" != x; then
15114 if test "x$EXTRA_PATH" = x; then
15115 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
15116 else
15117 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
15118 fi
15119 fi
15120
15121
15122 # Fallback default of just /bin if DEVKIT_PATH is not defined
15123 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
15124 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
15125 fi
15126
15127 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
15128 if test "x$TOOLCHAIN_PATH" = x; then
15129 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
15130 else
15131 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
15132 fi
15133 fi
15134
15135
15136 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
15137 # places for backwards compatiblity.
15138 if test "x$DEVKIT_SYSROOT" != x; then
15139 SYSROOT="$DEVKIT_SYSROOT"
15140 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
15141 SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
15142 elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
15143 SYSROOT="$DEVKIT_ROOT/$host/sys-root"
15144 fi
15145
15146
15147 fi
15148
15149
15150 # You can force the sysroot if the sysroot encoded into the compiler tools
15151 # is not correct.
15152
15153 # Check whether --with-sys-root was given.
15154 if test "${with_sys_root+set}" = set; then :
15155 withval=$with_sys_root; SYSROOT=$with_sys_root
15156
15157 fi
15158
15159
15160
15161 # Check whether --with-sysroot was given.
15162 if test "${with_sysroot+set}" = set; then :
15163 withval=$with_sysroot; SYSROOT=$with_sysroot
15164
15165 fi
15166
15167
15168
15169 # Check whether --with-tools-dir was given.
15170 if test "${with_tools_dir+set}" = set; then :
15171 withval=$with_tools_dir;
15172 if test "x$with_tools_dir" != x; then
15173 if test "x$TOOLCHAIN_PATH" = x; then
15174 TOOLCHAIN_PATH="$with_tools_dir"
15175 else
15176 TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
15177 fi
15178 fi
15179
15180
15181 fi
15182
15183
15184
15185 # Check whether --with-toolchain-path was given.
15186 if test "${with_toolchain_path+set}" = set; then :
15187 withval=$with_toolchain_path;
15188 if test "x$with_toolchain_path" != x; then
15189 if test "x$TOOLCHAIN_PATH" = x; then
15190 TOOLCHAIN_PATH="$with_toolchain_path"
15191 else
15192 TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15193 fi
15194 fi
15195
15196
15197 fi
15198
15199
15200
15201 # Check whether --with-extra-path was given.
15202 if test "${with_extra_path+set}" = set; then :
15203 withval=$with_extra_path;
15204 if test "x$with_extra_path" != x; then
15205 if test "x$EXTRA_PATH" = x; then
15206 EXTRA_PATH="$with_extra_path"
15207 else
15208 EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15209 fi
15210 fi
15211
15212
15213 fi
15214
15215
15216 if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
15217 # detect if Xcode is installed by running xcodebuild -version
15218 # if no Xcode installed, xcodebuild exits with 1
15219 # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
15220 if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
15221 # We need to use xcodebuild in the toolchain dir provided by the user, this will
15222 # fall back on the stub binary in /usr/bin/xcodebuild
15223 # Extract the first word of "xcodebuild", so it can be a program name with args.
15224 set dummy xcodebuild; ac_word=$2
15225 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15226 $as_echo_n "checking for $ac_word... " >&6; }
15227 if ${ac_cv_path_XCODEBUILD+:} false; then :
15228 $as_echo_n "(cached) " >&6
15229 else
15230 case $XCODEBUILD in
15231 [\\/]* | ?:[\\/]*)
15232 ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
15233 ;;
15234 *)
15235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15236 for as_dir in $TOOLCHAIN_PATH
15237 do
15238 IFS=$as_save_IFS
15239 test -z "$as_dir" && as_dir=.
15240 for ac_exec_ext in '' $ac_executable_extensions; do
15241 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15242 ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
15243 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15244 break 2
15245 fi
15246 done
15247 done
15248 IFS=$as_save_IFS
15249
15250 test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
15251 ;;
15252 esac
15253 fi
15254 XCODEBUILD=$ac_cv_path_XCODEBUILD
15255 if test -n "$XCODEBUILD"; then
15256 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
15257 $as_echo "$XCODEBUILD" >&6; }
15258 else
15259 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15260 $as_echo "no" >&6; }
15261 fi
15262
15263
15264 else
15265 # this should result in SYSROOT being empty, unless --with-sysroot is provided
15266 # when only the command line tools are installed there are no SDKs, so headers
15267 # are copied into the system frameworks
15268 XCODEBUILD=
15269
15270 fi
15271
15272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
15273 $as_echo_n "checking for sdk name... " >&6; }
15274
15275 # Check whether --with-sdk-name was given.
15276 if test "${with_sdk_name+set}" = set; then :
15277 withval=$with_sdk_name; SDKNAME=$with_sdk_name
15278
15279 fi
15280
15281 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
15282 $as_echo "$SDKNAME" >&6; }
15283
15284 # if toolchain path is specified then don't rely on system headers, they may not compile
15285 HAVE_SYSTEM_FRAMEWORK_HEADERS=0
15286 test -z "$TOOLCHAIN_PATH" && \
15287 HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
15288
15289 if test -z "$SYSROOT"; then
15290 if test -n "$XCODEBUILD"; then
15291 # if we don't have system headers, use default SDK name (last resort)
15292 if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15293 SDKNAME=${SDKNAME:-macosx}
15294 fi
15295
15296 if test -n "$SDKNAME"; then
15297 # Call xcodebuild to determine SYSROOT
15298 SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
15299 fi
15300 else
15301 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15302 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
15303 fi
15304 fi
15305 else
15306 # warn user if --with-sdk-name was also set
15307 if test -n "$with_sdk_name"; then
15308 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
15309 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
15310 fi
15311 fi
15312
15313 if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
15314 # If no system framework headers, then SYSROOT must be set, or we won't build
15315 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
15316 fi
15317
15318 # Perform a basic sanity test
15319 if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
15320 if test -z "$SYSROOT"; then
15321 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
15322 else
15323 as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
15324 fi
15325 fi
15326
15327 # set SDKROOT too, Xcode tools will pick it up
15328 SDKROOT=$SYSROOT
15329
15330 fi
15331
15332 # Prepend the extra path to the global path
15333
15334 if test "x$EXTRA_PATH" != x; then
15335 if test "x$PATH" = x; then
15336 PATH="$EXTRA_PATH"
15337 else
15338 PATH="$EXTRA_PATH:$PATH"
15339 fi
15340 fi
15341
15342
15343 if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15344 # Add extra search paths on solaris for utilities like ar and as etc...
15345 PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15346 fi
15347
15348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15349 $as_echo_n "checking for sysroot... " >&6; }
15350 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15351 $as_echo "$SYSROOT" >&6; }
15352 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15353 $as_echo_n "checking for toolchain path... " >&6; }
15354 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15355 $as_echo "$TOOLCHAIN_PATH" >&6; }
15356 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15357 $as_echo_n "checking for extra path... " >&6; }
15358 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15359 $as_echo "$EXTRA_PATH" >&6; }
15360
15361
15362 # To properly create a configuration name, we need to have the OpenJDK target
15363 # and options (variants and debug level) parsed.
15364
15365
15366
15367 # Check whether --with-conf-name was given.
15368 if test "${with_conf_name+set}" = set; then :
15369 withval=$with_conf_name; CONF_NAME=${with_conf_name}
15370 fi
15371
15372
15373 # Test from where we are running configure, in or outside of src root.
15374 { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15375 $as_echo_n "checking where to store configuration... " >&6; }
15376 if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15377 || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15378 || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15379 # We are running configure from the src root.
15380 # Create a default ./build/target-variant-debuglevel output root.
15381 if test "x${CONF_NAME}" = x; then
15382 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15383 $as_echo "in default location" >&6; }
15384 CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15385 else
15386 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15387 $as_echo "in build directory with custom name" >&6; }
15388 fi
15389 OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15390 $MKDIR -p "$OUTPUT_ROOT"
15391 if test ! -d "$OUTPUT_ROOT"; then
15392 as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15393 fi
15394 else
15395 # We are running configure from outside of the src dir.
15396 # Then use the current directory as output dir!
15397 # If configuration is situated in normal build directory, just use the build
15398 # directory name as configuration name, otherwise use the complete path.
15399 if test "x${CONF_NAME}" = x; then
15400 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15401 fi
15402 OUTPUT_ROOT="$CURDIR"
15403 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15404 $as_echo "in current directory" >&6; }
15405
15406 # WARNING: This might be a bad thing to do. You need to be sure you want to
15407 # have a configuration in this directory. Do some sanity checks!
15408
15409 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15410 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15411 # other files
15412 files_present=`$LS $OUTPUT_ROOT`
15413 # Configure has already touched config.log and confdefs.h in the current dir when this check
15414 # is performed.
15415 filtered_files=`$ECHO "$files_present" \
15416 | $SED -e 's/config.log//g' \
15417 -e 's/configure.log//g' \
15418 -e 's/confdefs.h//g' \
15419 -e 's/ //g' \
15420 | $TR -d '\n'`
15421 if test "x$filtered_files" != x; then
15422 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15423 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15424 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15425 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15426 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15427 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15428 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15429 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15430 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15431 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15432 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15433 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15434 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15435 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15436 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15437 fi
15438 fi
15439 fi
15440 { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15441 $as_echo_n "checking what configuration name to use... " >&6; }
15442 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15443 $as_echo "$CONF_NAME" >&6; }
15444
15445
15446 # Only process if variable expands to non-empty
15447
15448 if test "x$OUTPUT_ROOT" != x; then
15449 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15450
15451 # Input might be given as Windows format, start by converting to
15452 # unix format.
15453 path="$OUTPUT_ROOT"
15454 new_path=`$CYGPATH -u "$path"`
15455
15456 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15457 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15458 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15459 # "foo.exe" is OK but "foo" is an error.
15460 #
15461 # This test is therefore slightly more accurate than "test -f" to check for file precense.
15462 # It is also a way to make sure we got the proper file name for the real test later on.
15463 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15464 if test "x$test_shortpath" = x; then
15465 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15466 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15467 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15468 fi
15469
15470 # Call helper function which possibly converts this using DOS-style short mode.
15471 # If so, the updated path is stored in $new_path.
15472
15473 input_path="$new_path"
15474 # Check if we need to convert this using DOS-style short mode. If the path
15475 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15476 # take no chances and rewrite it.
15477 # Note: m4 eats our [], so we need to use [ and ] instead.
15478 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15479 if test "x$has_forbidden_chars" != x; then
15480 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15481 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15482 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15483 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15484 # Going to short mode and back again did indeed matter. Since short mode is
15485 # case insensitive, let's make it lowercase to improve readability.
15486 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15487 # Now convert it back to Unix-style (cygpath)
15488 input_path=`$CYGPATH -u "$shortmode_path"`
15489 new_path="$input_path"
15490 fi
15491 fi
15492
15493 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15494 if test "x$test_cygdrive_prefix" = x; then
15495 # As a simple fix, exclude /usr/bin since it's not a real path.
15496 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15497 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15498 # a path prefixed by /cygdrive for fixpath to work.
15499 new_path="$CYGWIN_ROOT_PATH$input_path"
15500 fi
15501 fi
15502
15503
15504 if test "x$path" != "x$new_path"; then
15505 OUTPUT_ROOT="$new_path"
15506 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15507 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15508 fi
15509
15510 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15511
15512 path="$OUTPUT_ROOT"
15513 has_colon=`$ECHO $path | $GREP ^.:`
15514 new_path="$path"
15515 if test "x$has_colon" = x; then
15516 # Not in mixed or Windows style, start by that.
15517 new_path=`cmd //c echo $path`
15518 fi
15519
15520
15521 input_path="$new_path"
15522 # Check if we need to convert this using DOS-style short mode. If the path
15523 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15524 # take no chances and rewrite it.
15525 # Note: m4 eats our [], so we need to use [ and ] instead.
15526 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15527 if test "x$has_forbidden_chars" != x; then
15528 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15529 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15530 fi
15531
15532
15533 windows_path="$new_path"
15534 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15535 unix_path=`$CYGPATH -u "$windows_path"`
15536 new_path="$unix_path"
15537 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15538 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15539 new_path="$unix_path"
15540 fi
15541
15542 if test "x$path" != "x$new_path"; then
15543 OUTPUT_ROOT="$new_path"
15544 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15545 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15546 fi
15547
15548 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15549 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15550
15551 else
15552 # We're on a unix platform. Hooray! :)
15553 path="$OUTPUT_ROOT"
15554 has_space=`$ECHO "$path" | $GREP " "`
15555 if test "x$has_space" != x; then
15556 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15557 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15558 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15559 fi
15560
15561 # Use eval to expand a potential ~
15562 eval path="$path"
15563 if test ! -f "$path" && test ! -d "$path"; then
15564 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15565 fi
15566
15567 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15568 fi
15569 fi
15570
15571
15572 CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
15573 $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
15574
15575 SPEC=$OUTPUT_ROOT/spec.gmk
15576
15577 CONF_NAME=$CONF_NAME
15578
15579 OUTPUT_ROOT=$OUTPUT_ROOT
15580
15581
15582
15583 # The spec.gmk file contains all variables for the make system.
15584 ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15585
15586 # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15587 ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15588
15589 # The bootcycle-spec.gmk file contains support for boot cycle builds.
15590 ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15591
15592 # The compare.sh is used to compare the build output to other builds.
15593 ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15594
15595 # The generated Makefile knows where the spec.gmk is and where the source is.
15596 # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15597 # which will look for generated configurations
15598 ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15599
15600
15601
15602 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15603
15604 for ac_prog in apt-get yum port pkgutil pkgadd
15605 do
15606 # Extract the first word of "$ac_prog", so it can be a program name with args.
15607 set dummy $ac_prog; ac_word=$2
15608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15609 $as_echo_n "checking for $ac_word... " >&6; }
15610 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15611 $as_echo_n "(cached) " >&6
15612 else
15613 if test -n "$PKGHANDLER"; then
15614 ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15615 else
15616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15617 for as_dir in $PATH
15618 do
15619 IFS=$as_save_IFS
15620 test -z "$as_dir" && as_dir=.
15621 for ac_exec_ext in '' $ac_executable_extensions; do
15622 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15623 ac_cv_prog_PKGHANDLER="$ac_prog"
15624 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15625 break 2
15626 fi
15627 done
15628 done
15629 IFS=$as_save_IFS
15630
15631 fi
15632 fi
15633 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15634 if test -n "$PKGHANDLER"; then
15635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15636 $as_echo "$PKGHANDLER" >&6; }
15637 else
15638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15639 $as_echo "no" >&6; }
15640 fi
15641
15642
15643 test -n "$PKGHANDLER" && break
15644 done
15645
15646
15647
15648 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15649
15650
15651 # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15652 if test "x$MAKE" != x; then
15653 # User has supplied a make, test it.
15654 if test ! -f "$MAKE"; then
15655 as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15656 fi
15657
15658 MAKE_CANDIDATE=""$MAKE""
15659 DESCRIPTION="user supplied MAKE=$MAKE"
15660
15661 # On Cygwin, we require a newer version of make than on other platforms
15662 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15663 MAKE_VERSION_EXPR="-e 4\."
15664 MAKE_REQUIRED_VERSION="4.0"
15665 else
15666 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
15667 MAKE_REQUIRED_VERSION="3.81"
15668 fi
15669
15670 if test "x$MAKE_CANDIDATE" != x; then
15671 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15672 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15673 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15674 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15675 if test "x$IS_GNU_MAKE" = x; then
15676 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15677 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15678 else
15679 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
15680 if test "x$IS_MODERN_MAKE" = x; then
15681 { $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
15682 $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;}
15683 else
15684 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15685 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15686 MAKE_EXPECTED_ENV='cygwin'
15687 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15688 MAKE_EXPECTED_ENV='msys'
15689 else
15690 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15691 fi
15692 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15693 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15694 else
15695 # Not relevant for non-Windows
15696 IS_MAKE_CORRECT_ENV=true
15697 fi
15698 if test "x$IS_MAKE_CORRECT_ENV" = x; then
15699 { $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
15700 $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;}
15701 else
15702 FOUND_MAKE=$MAKE_CANDIDATE
15703
15704 # Only process if variable expands to non-empty
15705
15706 if test "x$FOUND_MAKE" != x; then
15707 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15708
15709 # First separate the path from the arguments. This will split at the first
15710 # space.
15711 complete="$FOUND_MAKE"
15712 path="${complete%% *}"
15713 tmp="$complete EOL"
15714 arguments="${tmp#* }"
15715
15716 # Input might be given as Windows format, start by converting to
15717 # unix format.
15718 new_path=`$CYGPATH -u "$path"`
15719
15720 # Now try to locate executable using which
15721 new_path=`$WHICH "$new_path" 2> /dev/null`
15722 # bat and cmd files are not always considered executable in cygwin causing which
15723 # to not find them
15724 if test "x$new_path" = x \
15725 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15726 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15727 new_path=`$CYGPATH -u "$path"`
15728 fi
15729 if test "x$new_path" = x; then
15730 # Oops. Which didn't find the executable.
15731 # The splitting of arguments from the executable at a space might have been incorrect,
15732 # since paths with space are more likely in Windows. Give it another try with the whole
15733 # argument.
15734 path="$complete"
15735 arguments="EOL"
15736 new_path=`$CYGPATH -u "$path"`
15737 new_path=`$WHICH "$new_path" 2> /dev/null`
15738 # bat and cmd files are not always considered executable in cygwin causing which
15739 # to not find them
15740 if test "x$new_path" = x \
15741 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15742 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15743 new_path=`$CYGPATH -u "$path"`
15744 fi
15745 if test "x$new_path" = x; then
15746 # It's still not found. Now this is an unrecoverable error.
15747 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15748 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15749 has_space=`$ECHO "$complete" | $GREP " "`
15750 if test "x$has_space" != x; then
15751 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15752 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15753 fi
15754 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15755 fi
15756 fi
15757
15758 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15759 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15760 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15761 # "foo.exe" is OK but "foo" is an error.
15762 #
15763 # This test is therefore slightly more accurate than "test -f" to check for file presence.
15764 # It is also a way to make sure we got the proper file name for the real test later on.
15765 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15766 if test "x$test_shortpath" = x; then
15767 # Short path failed, file does not exist as specified.
15768 # Try adding .exe or .cmd
15769 if test -f "${new_path}.exe"; then
15770 input_to_shortpath="${new_path}.exe"
15771 elif test -f "${new_path}.cmd"; then
15772 input_to_shortpath="${new_path}.cmd"
15773 else
15774 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15775 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15776 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15777 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15778 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15779 fi
15780 else
15781 input_to_shortpath="$new_path"
15782 fi
15783
15784 # Call helper function which possibly converts this using DOS-style short mode.
15785 # If so, the updated path is stored in $new_path.
15786 new_path="$input_to_shortpath"
15787
15788 input_path="$input_to_shortpath"
15789 # Check if we need to convert this using DOS-style short mode. If the path
15790 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15791 # take no chances and rewrite it.
15792 # Note: m4 eats our [], so we need to use [ and ] instead.
15793 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15794 if test "x$has_forbidden_chars" != x; then
15795 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15796 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15797 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15798 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15799 # Going to short mode and back again did indeed matter. Since short mode is
15800 # case insensitive, let's make it lowercase to improve readability.
15801 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15802 # Now convert it back to Unix-style (cygpath)
15803 input_path=`$CYGPATH -u "$shortmode_path"`
15804 new_path="$input_path"
15805 fi
15806 fi
15807
15808 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15809 if test "x$test_cygdrive_prefix" = x; then
15810 # As a simple fix, exclude /usr/bin since it's not a real path.
15811 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15812 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15813 # a path prefixed by /cygdrive for fixpath to work.
15814 new_path="$CYGWIN_ROOT_PATH$input_path"
15815 fi
15816 fi
15817
15818 # remove trailing .exe if any
15819 new_path="${new_path/%.exe/}"
15820
15821 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15822
15823 # First separate the path from the arguments. This will split at the first
15824 # space.
15825 complete="$FOUND_MAKE"
15826 path="${complete%% *}"
15827 tmp="$complete EOL"
15828 arguments="${tmp#* }"
15829
15830 # Input might be given as Windows format, start by converting to
15831 # unix format.
15832 new_path="$path"
15833
15834 windows_path="$new_path"
15835 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15836 unix_path=`$CYGPATH -u "$windows_path"`
15837 new_path="$unix_path"
15838 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15839 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15840 new_path="$unix_path"
15841 fi
15842
15843
15844 # Now try to locate executable using which
15845 new_path=`$WHICH "$new_path" 2> /dev/null`
15846
15847 if test "x$new_path" = x; then
15848 # Oops. Which didn't find the executable.
15849 # The splitting of arguments from the executable at a space might have been incorrect,
15850 # since paths with space are more likely in Windows. Give it another try with the whole
15851 # argument.
15852 path="$complete"
15853 arguments="EOL"
15854 new_path="$path"
15855
15856 windows_path="$new_path"
15857 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15858 unix_path=`$CYGPATH -u "$windows_path"`
15859 new_path="$unix_path"
15860 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15861 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15862 new_path="$unix_path"
15863 fi
15864
15865
15866 new_path=`$WHICH "$new_path" 2> /dev/null`
15867 # bat and cmd files are not always considered executable in MSYS causing which
15868 # to not find them
15869 if test "x$new_path" = x \
15870 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15871 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15872 new_path="$path"
15873
15874 windows_path="$new_path"
15875 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15876 unix_path=`$CYGPATH -u "$windows_path"`
15877 new_path="$unix_path"
15878 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15879 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15880 new_path="$unix_path"
15881 fi
15882
15883 fi
15884
15885 if test "x$new_path" = x; then
15886 # It's still not found. Now this is an unrecoverable error.
15887 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15888 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15889 has_space=`$ECHO "$complete" | $GREP " "`
15890 if test "x$has_space" != x; then
15891 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15892 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15893 fi
15894 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15895 fi
15896 fi
15897
15898 # Now new_path has a complete unix path to the binary
15899 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15900 # Keep paths in /bin as-is, but remove trailing .exe if any
15901 new_path="${new_path/%.exe/}"
15902 # Do not save /bin paths to all_fixpath_prefixes!
15903 else
15904 # Not in mixed or Windows style, start by that.
15905 new_path=`cmd //c echo $new_path`
15906
15907 input_path="$new_path"
15908 # Check if we need to convert this using DOS-style short mode. If the path
15909 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15910 # take no chances and rewrite it.
15911 # Note: m4 eats our [], so we need to use [ and ] instead.
15912 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15913 if test "x$has_forbidden_chars" != x; then
15914 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15915 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15916 fi
15917
15918 # Output is in $new_path
15919
15920 windows_path="$new_path"
15921 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15922 unix_path=`$CYGPATH -u "$windows_path"`
15923 new_path="$unix_path"
15924 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15925 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15926 new_path="$unix_path"
15927 fi
15928
15929 # remove trailing .exe if any
15930 new_path="${new_path/%.exe/}"
15931
15932 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15933 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15934 fi
15935
15936 else
15937 # We're on a unix platform. Hooray! :)
15938 # First separate the path from the arguments. This will split at the first
15939 # space.
15940 complete="$FOUND_MAKE"
15941 path="${complete%% *}"
15942 tmp="$complete EOL"
15943 arguments="${tmp#* }"
15944
15945 # Cannot rely on the command "which" here since it doesn't always work.
15946 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15947 if test -z "$is_absolute_path"; then
15948 # Path to executable is not absolute. Find it.
15949 IFS_save="$IFS"
15950 IFS=:
15951 for p in $PATH; do
15952 if test -f "$p/$path" && test -x "$p/$path"; then
15953 new_path="$p/$path"
15954 break
15955 fi
15956 done
15957 IFS="$IFS_save"
15958 else
15959 # This is an absolute path, we can use it without further modifications.
15960 new_path="$path"
15961 fi
15962
15963 if test "x$new_path" = x; then
15964 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15965 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15966 has_space=`$ECHO "$complete" | $GREP " "`
15967 if test "x$has_space" != x; then
15968 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15969 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15970 fi
15971 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15972 fi
15973 fi
15974
15975 # Now join together the path and the arguments once again
15976 if test "x$arguments" != xEOL; then
15977 new_complete="$new_path ${arguments% *}"
15978 else
15979 new_complete="$new_path"
15980 fi
15981
15982 if test "x$complete" != "x$new_complete"; then
15983 FOUND_MAKE="$new_complete"
15984 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15985 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15986 fi
15987 fi
15988
15989 fi
15990 fi
15991 fi
15992 fi
15993
15994 if test "x$FOUND_MAKE" = x; then
15995 as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
15996 fi
15997 else
15998 # Try our hardest to locate a correct version of GNU make
15999 for ac_prog in gmake
16000 do
16001 # Extract the first word of "$ac_prog", so it can be a program name with args.
16002 set dummy $ac_prog; ac_word=$2
16003 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16004 $as_echo_n "checking for $ac_word... " >&6; }
16005 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
16006 $as_echo_n "(cached) " >&6
16007 else
16008 case $CHECK_GMAKE in
16009 [\\/]* | ?:[\\/]*)
16010 ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
16011 ;;
16012 *)
16013 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16014 for as_dir in $PATH
16015 do
16016 IFS=$as_save_IFS
16017 test -z "$as_dir" && as_dir=.
16018 for ac_exec_ext in '' $ac_executable_extensions; do
16019 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16020 ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16021 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16022 break 2
16023 fi
16024 done
16025 done
16026 IFS=$as_save_IFS
16027
16028 ;;
16029 esac
16030 fi
16031 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
16032 if test -n "$CHECK_GMAKE"; then
16033 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
16034 $as_echo "$CHECK_GMAKE" >&6; }
16035 else
16036 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16037 $as_echo "no" >&6; }
16038 fi
16039
16040
16041 test -n "$CHECK_GMAKE" && break
16042 done
16043
16044
16045 MAKE_CANDIDATE=""$CHECK_GMAKE""
16046 DESCRIPTION="gmake in PATH"
16047
16048 # On Cygwin, we require a newer version of make than on other platforms
16049 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16050 MAKE_VERSION_EXPR="-e 4\."
16051 MAKE_REQUIRED_VERSION="4.0"
16052 else
16053 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16054 MAKE_REQUIRED_VERSION="3.81"
16055 fi
16056
16057 if test "x$MAKE_CANDIDATE" != x; then
16058 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16059 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16060 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16061 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16062 if test "x$IS_GNU_MAKE" = x; then
16063 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16064 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16065 else
16066 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16067 if test "x$IS_MODERN_MAKE" = x; then
16068 { $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
16069 $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;}
16070 else
16071 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16072 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16073 MAKE_EXPECTED_ENV='cygwin'
16074 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16075 MAKE_EXPECTED_ENV='msys'
16076 else
16077 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16078 fi
16079 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16080 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16081 else
16082 # Not relevant for non-Windows
16083 IS_MAKE_CORRECT_ENV=true
16084 fi
16085 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16086 { $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
16087 $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;}
16088 else
16089 FOUND_MAKE=$MAKE_CANDIDATE
16090
16091 # Only process if variable expands to non-empty
16092
16093 if test "x$FOUND_MAKE" != x; then
16094 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16095
16096 # First separate the path from the arguments. This will split at the first
16097 # space.
16098 complete="$FOUND_MAKE"
16099 path="${complete%% *}"
16100 tmp="$complete EOL"
16101 arguments="${tmp#* }"
16102
16103 # Input might be given as Windows format, start by converting to
16104 # unix format.
16105 new_path=`$CYGPATH -u "$path"`
16106
16107 # Now try to locate executable using which
16108 new_path=`$WHICH "$new_path" 2> /dev/null`
16109 # bat and cmd files are not always considered executable in cygwin causing which
16110 # to not find them
16111 if test "x$new_path" = x \
16112 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16113 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16114 new_path=`$CYGPATH -u "$path"`
16115 fi
16116 if test "x$new_path" = x; then
16117 # Oops. Which didn't find the executable.
16118 # The splitting of arguments from the executable at a space might have been incorrect,
16119 # since paths with space are more likely in Windows. Give it another try with the whole
16120 # argument.
16121 path="$complete"
16122 arguments="EOL"
16123 new_path=`$CYGPATH -u "$path"`
16124 new_path=`$WHICH "$new_path" 2> /dev/null`
16125 # bat and cmd files are not always considered executable in cygwin causing which
16126 # to not find them
16127 if test "x$new_path" = x \
16128 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16129 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16130 new_path=`$CYGPATH -u "$path"`
16131 fi
16132 if test "x$new_path" = x; then
16133 # It's still not found. Now this is an unrecoverable error.
16134 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16135 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16136 has_space=`$ECHO "$complete" | $GREP " "`
16137 if test "x$has_space" != x; then
16138 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16139 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16140 fi
16141 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16142 fi
16143 fi
16144
16145 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16146 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16147 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16148 # "foo.exe" is OK but "foo" is an error.
16149 #
16150 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16151 # It is also a way to make sure we got the proper file name for the real test later on.
16152 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16153 if test "x$test_shortpath" = x; then
16154 # Short path failed, file does not exist as specified.
16155 # Try adding .exe or .cmd
16156 if test -f "${new_path}.exe"; then
16157 input_to_shortpath="${new_path}.exe"
16158 elif test -f "${new_path}.cmd"; then
16159 input_to_shortpath="${new_path}.cmd"
16160 else
16161 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16162 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16163 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16164 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16165 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16166 fi
16167 else
16168 input_to_shortpath="$new_path"
16169 fi
16170
16171 # Call helper function which possibly converts this using DOS-style short mode.
16172 # If so, the updated path is stored in $new_path.
16173 new_path="$input_to_shortpath"
16174
16175 input_path="$input_to_shortpath"
16176 # Check if we need to convert this using DOS-style short mode. If the path
16177 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16178 # take no chances and rewrite it.
16179 # Note: m4 eats our [], so we need to use [ and ] instead.
16180 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16181 if test "x$has_forbidden_chars" != x; then
16182 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16183 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16184 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16185 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16186 # Going to short mode and back again did indeed matter. Since short mode is
16187 # case insensitive, let's make it lowercase to improve readability.
16188 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16189 # Now convert it back to Unix-style (cygpath)
16190 input_path=`$CYGPATH -u "$shortmode_path"`
16191 new_path="$input_path"
16192 fi
16193 fi
16194
16195 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16196 if test "x$test_cygdrive_prefix" = x; then
16197 # As a simple fix, exclude /usr/bin since it's not a real path.
16198 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16199 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16200 # a path prefixed by /cygdrive for fixpath to work.
16201 new_path="$CYGWIN_ROOT_PATH$input_path"
16202 fi
16203 fi
16204
16205 # remove trailing .exe if any
16206 new_path="${new_path/%.exe/}"
16207
16208 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16209
16210 # First separate the path from the arguments. This will split at the first
16211 # space.
16212 complete="$FOUND_MAKE"
16213 path="${complete%% *}"
16214 tmp="$complete EOL"
16215 arguments="${tmp#* }"
16216
16217 # Input might be given as Windows format, start by converting to
16218 # unix format.
16219 new_path="$path"
16220
16221 windows_path="$new_path"
16222 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16223 unix_path=`$CYGPATH -u "$windows_path"`
16224 new_path="$unix_path"
16225 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16226 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16227 new_path="$unix_path"
16228 fi
16229
16230
16231 # Now try to locate executable using which
16232 new_path=`$WHICH "$new_path" 2> /dev/null`
16233
16234 if test "x$new_path" = x; then
16235 # Oops. Which didn't find the executable.
16236 # The splitting of arguments from the executable at a space might have been incorrect,
16237 # since paths with space are more likely in Windows. Give it another try with the whole
16238 # argument.
16239 path="$complete"
16240 arguments="EOL"
16241 new_path="$path"
16242
16243 windows_path="$new_path"
16244 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16245 unix_path=`$CYGPATH -u "$windows_path"`
16246 new_path="$unix_path"
16247 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16248 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16249 new_path="$unix_path"
16250 fi
16251
16252
16253 new_path=`$WHICH "$new_path" 2> /dev/null`
16254 # bat and cmd files are not always considered executable in MSYS causing which
16255 # to not find them
16256 if test "x$new_path" = x \
16257 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16258 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16259 new_path="$path"
16260
16261 windows_path="$new_path"
16262 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16263 unix_path=`$CYGPATH -u "$windows_path"`
16264 new_path="$unix_path"
16265 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16266 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16267 new_path="$unix_path"
16268 fi
16269
16270 fi
16271
16272 if test "x$new_path" = x; then
16273 # It's still not found. Now this is an unrecoverable error.
16274 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16275 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16276 has_space=`$ECHO "$complete" | $GREP " "`
16277 if test "x$has_space" != x; then
16278 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16279 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16280 fi
16281 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16282 fi
16283 fi
16284
16285 # Now new_path has a complete unix path to the binary
16286 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16287 # Keep paths in /bin as-is, but remove trailing .exe if any
16288 new_path="${new_path/%.exe/}"
16289 # Do not save /bin paths to all_fixpath_prefixes!
16290 else
16291 # Not in mixed or Windows style, start by that.
16292 new_path=`cmd //c echo $new_path`
16293
16294 input_path="$new_path"
16295 # Check if we need to convert this using DOS-style short mode. If the path
16296 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16297 # take no chances and rewrite it.
16298 # Note: m4 eats our [], so we need to use [ and ] instead.
16299 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16300 if test "x$has_forbidden_chars" != x; then
16301 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16302 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16303 fi
16304
16305 # Output is in $new_path
16306
16307 windows_path="$new_path"
16308 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16309 unix_path=`$CYGPATH -u "$windows_path"`
16310 new_path="$unix_path"
16311 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16312 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16313 new_path="$unix_path"
16314 fi
16315
16316 # remove trailing .exe if any
16317 new_path="${new_path/%.exe/}"
16318
16319 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16320 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16321 fi
16322
16323 else
16324 # We're on a unix platform. Hooray! :)
16325 # First separate the path from the arguments. This will split at the first
16326 # space.
16327 complete="$FOUND_MAKE"
16328 path="${complete%% *}"
16329 tmp="$complete EOL"
16330 arguments="${tmp#* }"
16331
16332 # Cannot rely on the command "which" here since it doesn't always work.
16333 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16334 if test -z "$is_absolute_path"; then
16335 # Path to executable is not absolute. Find it.
16336 IFS_save="$IFS"
16337 IFS=:
16338 for p in $PATH; do
16339 if test -f "$p/$path" && test -x "$p/$path"; then
16340 new_path="$p/$path"
16341 break
16342 fi
16343 done
16344 IFS="$IFS_save"
16345 else
16346 # This is an absolute path, we can use it without further modifications.
16347 new_path="$path"
16348 fi
16349
16350 if test "x$new_path" = x; then
16351 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16352 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16353 has_space=`$ECHO "$complete" | $GREP " "`
16354 if test "x$has_space" != x; then
16355 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16356 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16357 fi
16358 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16359 fi
16360 fi
16361
16362 # Now join together the path and the arguments once again
16363 if test "x$arguments" != xEOL; then
16364 new_complete="$new_path ${arguments% *}"
16365 else
16366 new_complete="$new_path"
16367 fi
16368
16369 if test "x$complete" != "x$new_complete"; then
16370 FOUND_MAKE="$new_complete"
16371 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16372 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16373 fi
16374 fi
16375
16376 fi
16377 fi
16378 fi
16379 fi
16380
16381
16382 if test "x$FOUND_MAKE" = x; then
16383 for ac_prog in make
16384 do
16385 # Extract the first word of "$ac_prog", so it can be a program name with args.
16386 set dummy $ac_prog; ac_word=$2
16387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16388 $as_echo_n "checking for $ac_word... " >&6; }
16389 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16390 $as_echo_n "(cached) " >&6
16391 else
16392 case $CHECK_MAKE in
16393 [\\/]* | ?:[\\/]*)
16394 ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16395 ;;
16396 *)
16397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16398 for as_dir in $PATH
16399 do
16400 IFS=$as_save_IFS
16401 test -z "$as_dir" && as_dir=.
16402 for ac_exec_ext in '' $ac_executable_extensions; do
16403 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16404 ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16405 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16406 break 2
16407 fi
16408 done
16409 done
16410 IFS=$as_save_IFS
16411
16412 ;;
16413 esac
16414 fi
16415 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16416 if test -n "$CHECK_MAKE"; then
16417 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16418 $as_echo "$CHECK_MAKE" >&6; }
16419 else
16420 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16421 $as_echo "no" >&6; }
16422 fi
16423
16424
16425 test -n "$CHECK_MAKE" && break
16426 done
16427
16428
16429 MAKE_CANDIDATE=""$CHECK_MAKE""
16430 DESCRIPTION="make in PATH"
16431
16432 # On Cygwin, we require a newer version of make than on other platforms
16433 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16434 MAKE_VERSION_EXPR="-e 4\."
16435 MAKE_REQUIRED_VERSION="4.0"
16436 else
16437 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16438 MAKE_REQUIRED_VERSION="3.81"
16439 fi
16440
16441 if test "x$MAKE_CANDIDATE" != x; then
16442 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16443 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16444 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16445 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16446 if test "x$IS_GNU_MAKE" = x; then
16447 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16448 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16449 else
16450 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16451 if test "x$IS_MODERN_MAKE" = x; then
16452 { $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
16453 $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;}
16454 else
16455 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16456 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16457 MAKE_EXPECTED_ENV='cygwin'
16458 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16459 MAKE_EXPECTED_ENV='msys'
16460 else
16461 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16462 fi
16463 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16464 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16465 else
16466 # Not relevant for non-Windows
16467 IS_MAKE_CORRECT_ENV=true
16468 fi
16469 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16470 { $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
16471 $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;}
16472 else
16473 FOUND_MAKE=$MAKE_CANDIDATE
16474
16475 # Only process if variable expands to non-empty
16476
16477 if test "x$FOUND_MAKE" != x; then
16478 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16479
16480 # First separate the path from the arguments. This will split at the first
16481 # space.
16482 complete="$FOUND_MAKE"
16483 path="${complete%% *}"
16484 tmp="$complete EOL"
16485 arguments="${tmp#* }"
16486
16487 # Input might be given as Windows format, start by converting to
16488 # unix format.
16489 new_path=`$CYGPATH -u "$path"`
16490
16491 # Now try to locate executable using which
16492 new_path=`$WHICH "$new_path" 2> /dev/null`
16493 # bat and cmd files are not always considered executable in cygwin causing which
16494 # to not find them
16495 if test "x$new_path" = x \
16496 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16497 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16498 new_path=`$CYGPATH -u "$path"`
16499 fi
16500 if test "x$new_path" = x; then
16501 # Oops. Which didn't find the executable.
16502 # The splitting of arguments from the executable at a space might have been incorrect,
16503 # since paths with space are more likely in Windows. Give it another try with the whole
16504 # argument.
16505 path="$complete"
16506 arguments="EOL"
16507 new_path=`$CYGPATH -u "$path"`
16508 new_path=`$WHICH "$new_path" 2> /dev/null`
16509 # bat and cmd files are not always considered executable in cygwin causing which
16510 # to not find them
16511 if test "x$new_path" = x \
16512 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16513 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16514 new_path=`$CYGPATH -u "$path"`
16515 fi
16516 if test "x$new_path" = x; then
16517 # It's still not found. Now this is an unrecoverable error.
16518 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16519 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16520 has_space=`$ECHO "$complete" | $GREP " "`
16521 if test "x$has_space" != x; then
16522 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16523 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16524 fi
16525 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16526 fi
16527 fi
16528
16529 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16530 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16531 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16532 # "foo.exe" is OK but "foo" is an error.
16533 #
16534 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16535 # It is also a way to make sure we got the proper file name for the real test later on.
16536 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16537 if test "x$test_shortpath" = x; then
16538 # Short path failed, file does not exist as specified.
16539 # Try adding .exe or .cmd
16540 if test -f "${new_path}.exe"; then
16541 input_to_shortpath="${new_path}.exe"
16542 elif test -f "${new_path}.cmd"; then
16543 input_to_shortpath="${new_path}.cmd"
16544 else
16545 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16546 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16547 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16548 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16549 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16550 fi
16551 else
16552 input_to_shortpath="$new_path"
16553 fi
16554
16555 # Call helper function which possibly converts this using DOS-style short mode.
16556 # If so, the updated path is stored in $new_path.
16557 new_path="$input_to_shortpath"
16558
16559 input_path="$input_to_shortpath"
16560 # Check if we need to convert this using DOS-style short mode. If the path
16561 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16562 # take no chances and rewrite it.
16563 # Note: m4 eats our [], so we need to use [ and ] instead.
16564 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16565 if test "x$has_forbidden_chars" != x; then
16566 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16567 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16568 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16569 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16570 # Going to short mode and back again did indeed matter. Since short mode is
16571 # case insensitive, let's make it lowercase to improve readability.
16572 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16573 # Now convert it back to Unix-style (cygpath)
16574 input_path=`$CYGPATH -u "$shortmode_path"`
16575 new_path="$input_path"
16576 fi
16577 fi
16578
16579 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16580 if test "x$test_cygdrive_prefix" = x; then
16581 # As a simple fix, exclude /usr/bin since it's not a real path.
16582 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16583 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16584 # a path prefixed by /cygdrive for fixpath to work.
16585 new_path="$CYGWIN_ROOT_PATH$input_path"
16586 fi
16587 fi
16588
16589 # remove trailing .exe if any
16590 new_path="${new_path/%.exe/}"
16591
16592 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16593
16594 # First separate the path from the arguments. This will split at the first
16595 # space.
16596 complete="$FOUND_MAKE"
16597 path="${complete%% *}"
16598 tmp="$complete EOL"
16599 arguments="${tmp#* }"
16600
16601 # Input might be given as Windows format, start by converting to
16602 # unix format.
16603 new_path="$path"
16604
16605 windows_path="$new_path"
16606 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16607 unix_path=`$CYGPATH -u "$windows_path"`
16608 new_path="$unix_path"
16609 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16610 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16611 new_path="$unix_path"
16612 fi
16613
16614
16615 # Now try to locate executable using which
16616 new_path=`$WHICH "$new_path" 2> /dev/null`
16617
16618 if test "x$new_path" = x; then
16619 # Oops. Which didn't find the executable.
16620 # The splitting of arguments from the executable at a space might have been incorrect,
16621 # since paths with space are more likely in Windows. Give it another try with the whole
16622 # argument.
16623 path="$complete"
16624 arguments="EOL"
16625 new_path="$path"
16626
16627 windows_path="$new_path"
16628 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16629 unix_path=`$CYGPATH -u "$windows_path"`
16630 new_path="$unix_path"
16631 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16632 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16633 new_path="$unix_path"
16634 fi
16635
16636
16637 new_path=`$WHICH "$new_path" 2> /dev/null`
16638 # bat and cmd files are not always considered executable in MSYS causing which
16639 # to not find them
16640 if test "x$new_path" = x \
16641 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16642 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16643 new_path="$path"
16644
16645 windows_path="$new_path"
16646 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16647 unix_path=`$CYGPATH -u "$windows_path"`
16648 new_path="$unix_path"
16649 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16650 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16651 new_path="$unix_path"
16652 fi
16653
16654 fi
16655
16656 if test "x$new_path" = x; then
16657 # It's still not found. Now this is an unrecoverable error.
16658 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16659 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16660 has_space=`$ECHO "$complete" | $GREP " "`
16661 if test "x$has_space" != x; then
16662 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16663 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16664 fi
16665 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16666 fi
16667 fi
16668
16669 # Now new_path has a complete unix path to the binary
16670 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16671 # Keep paths in /bin as-is, but remove trailing .exe if any
16672 new_path="${new_path/%.exe/}"
16673 # Do not save /bin paths to all_fixpath_prefixes!
16674 else
16675 # Not in mixed or Windows style, start by that.
16676 new_path=`cmd //c echo $new_path`
16677
16678 input_path="$new_path"
16679 # Check if we need to convert this using DOS-style short mode. If the path
16680 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16681 # take no chances and rewrite it.
16682 # Note: m4 eats our [], so we need to use [ and ] instead.
16683 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16684 if test "x$has_forbidden_chars" != x; then
16685 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16686 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16687 fi
16688
16689 # Output is in $new_path
16690
16691 windows_path="$new_path"
16692 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16693 unix_path=`$CYGPATH -u "$windows_path"`
16694 new_path="$unix_path"
16695 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16696 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16697 new_path="$unix_path"
16698 fi
16699
16700 # remove trailing .exe if any
16701 new_path="${new_path/%.exe/}"
16702
16703 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16704 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16705 fi
16706
16707 else
16708 # We're on a unix platform. Hooray! :)
16709 # First separate the path from the arguments. This will split at the first
16710 # space.
16711 complete="$FOUND_MAKE"
16712 path="${complete%% *}"
16713 tmp="$complete EOL"
16714 arguments="${tmp#* }"
16715
16716 # Cannot rely on the command "which" here since it doesn't always work.
16717 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16718 if test -z "$is_absolute_path"; then
16719 # Path to executable is not absolute. Find it.
16720 IFS_save="$IFS"
16721 IFS=:
16722 for p in $PATH; do
16723 if test -f "$p/$path" && test -x "$p/$path"; then
16724 new_path="$p/$path"
16725 break
16726 fi
16727 done
16728 IFS="$IFS_save"
16729 else
16730 # This is an absolute path, we can use it without further modifications.
16731 new_path="$path"
16732 fi
16733
16734 if test "x$new_path" = x; then
16735 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16736 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16737 has_space=`$ECHO "$complete" | $GREP " "`
16738 if test "x$has_space" != x; then
16739 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16740 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16741 fi
16742 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16743 fi
16744 fi
16745
16746 # Now join together the path and the arguments once again
16747 if test "x$arguments" != xEOL; then
16748 new_complete="$new_path ${arguments% *}"
16749 else
16750 new_complete="$new_path"
16751 fi
16752
16753 if test "x$complete" != "x$new_complete"; then
16754 FOUND_MAKE="$new_complete"
16755 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16756 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16757 fi
16758 fi
16759
16760 fi
16761 fi
16762 fi
16763 fi
16764
16765 fi
16766
16767 if test "x$FOUND_MAKE" = x; then
16768 if test "x$TOOLCHAIN_PATH" != x; then
16769 # We have a toolchain path, check that as well before giving up.
16770 OLD_PATH=$PATH
16771 PATH=$TOOLCHAIN_PATH:$PATH
16772 for ac_prog in gmake
16773 do
16774 # Extract the first word of "$ac_prog", so it can be a program name with args.
16775 set dummy $ac_prog; ac_word=$2
16776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16777 $as_echo_n "checking for $ac_word... " >&6; }
16778 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16779 $as_echo_n "(cached) " >&6
16780 else
16781 case $CHECK_TOOLSDIR_GMAKE in
16782 [\\/]* | ?:[\\/]*)
16783 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16784 ;;
16785 *)
16786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16787 for as_dir in $PATH
16788 do
16789 IFS=$as_save_IFS
16790 test -z "$as_dir" && as_dir=.
16791 for ac_exec_ext in '' $ac_executable_extensions; do
16792 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16793 ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16794 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16795 break 2
16796 fi
16797 done
16798 done
16799 IFS=$as_save_IFS
16800
16801 ;;
16802 esac
16803 fi
16804 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16805 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16806 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16807 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16808 else
16809 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16810 $as_echo "no" >&6; }
16811 fi
16812
16813
16814 test -n "$CHECK_TOOLSDIR_GMAKE" && break
16815 done
16816
16817
16818 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16819 DESCRIPTION="gmake in tools-dir"
16820
16821 # On Cygwin, we require a newer version of make than on other platforms
16822 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16823 MAKE_VERSION_EXPR="-e 4\."
16824 MAKE_REQUIRED_VERSION="4.0"
16825 else
16826 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16827 MAKE_REQUIRED_VERSION="3.81"
16828 fi
16829
16830 if test "x$MAKE_CANDIDATE" != x; then
16831 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16832 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16833 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16834 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16835 if test "x$IS_GNU_MAKE" = x; then
16836 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16837 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16838 else
16839 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16840 if test "x$IS_MODERN_MAKE" = x; then
16841 { $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
16842 $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;}
16843 else
16844 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16845 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16846 MAKE_EXPECTED_ENV='cygwin'
16847 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16848 MAKE_EXPECTED_ENV='msys'
16849 else
16850 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16851 fi
16852 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16853 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16854 else
16855 # Not relevant for non-Windows
16856 IS_MAKE_CORRECT_ENV=true
16857 fi
16858 if test "x$IS_MAKE_CORRECT_ENV" = x; then
16859 { $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
16860 $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;}
16861 else
16862 FOUND_MAKE=$MAKE_CANDIDATE
16863
16864 # Only process if variable expands to non-empty
16865
16866 if test "x$FOUND_MAKE" != x; then
16867 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16868
16869 # First separate the path from the arguments. This will split at the first
16870 # space.
16871 complete="$FOUND_MAKE"
16872 path="${complete%% *}"
16873 tmp="$complete EOL"
16874 arguments="${tmp#* }"
16875
16876 # Input might be given as Windows format, start by converting to
16877 # unix format.
16878 new_path=`$CYGPATH -u "$path"`
16879
16880 # Now try to locate executable using which
16881 new_path=`$WHICH "$new_path" 2> /dev/null`
16882 # bat and cmd files are not always considered executable in cygwin causing which
16883 # to not find them
16884 if test "x$new_path" = x \
16885 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16886 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16887 new_path=`$CYGPATH -u "$path"`
16888 fi
16889 if test "x$new_path" = x; then
16890 # Oops. Which didn't find the executable.
16891 # The splitting of arguments from the executable at a space might have been incorrect,
16892 # since paths with space are more likely in Windows. Give it another try with the whole
16893 # argument.
16894 path="$complete"
16895 arguments="EOL"
16896 new_path=`$CYGPATH -u "$path"`
16897 new_path=`$WHICH "$new_path" 2> /dev/null`
16898 # bat and cmd files are not always considered executable in cygwin causing which
16899 # to not find them
16900 if test "x$new_path" = x \
16901 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16902 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16903 new_path=`$CYGPATH -u "$path"`
16904 fi
16905 if test "x$new_path" = x; then
16906 # It's still not found. Now this is an unrecoverable error.
16907 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16908 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16909 has_space=`$ECHO "$complete" | $GREP " "`
16910 if test "x$has_space" != x; then
16911 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16912 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16913 fi
16914 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16915 fi
16916 fi
16917
16918 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16919 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16920 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16921 # "foo.exe" is OK but "foo" is an error.
16922 #
16923 # This test is therefore slightly more accurate than "test -f" to check for file presence.
16924 # It is also a way to make sure we got the proper file name for the real test later on.
16925 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16926 if test "x$test_shortpath" = x; then
16927 # Short path failed, file does not exist as specified.
16928 # Try adding .exe or .cmd
16929 if test -f "${new_path}.exe"; then
16930 input_to_shortpath="${new_path}.exe"
16931 elif test -f "${new_path}.cmd"; then
16932 input_to_shortpath="${new_path}.cmd"
16933 else
16934 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16935 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16936 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16937 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16938 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16939 fi
16940 else
16941 input_to_shortpath="$new_path"
16942 fi
16943
16944 # Call helper function which possibly converts this using DOS-style short mode.
16945 # If so, the updated path is stored in $new_path.
16946 new_path="$input_to_shortpath"
16947
16948 input_path="$input_to_shortpath"
16949 # Check if we need to convert this using DOS-style short mode. If the path
16950 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16951 # take no chances and rewrite it.
16952 # Note: m4 eats our [], so we need to use [ and ] instead.
16953 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16954 if test "x$has_forbidden_chars" != x; then
16955 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16956 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16957 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16958 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16959 # Going to short mode and back again did indeed matter. Since short mode is
16960 # case insensitive, let's make it lowercase to improve readability.
16961 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16962 # Now convert it back to Unix-style (cygpath)
16963 input_path=`$CYGPATH -u "$shortmode_path"`
16964 new_path="$input_path"
16965 fi
16966 fi
16967
16968 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16969 if test "x$test_cygdrive_prefix" = x; then
16970 # As a simple fix, exclude /usr/bin since it's not a real path.
16971 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16972 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16973 # a path prefixed by /cygdrive for fixpath to work.
16974 new_path="$CYGWIN_ROOT_PATH$input_path"
16975 fi
16976 fi
16977
16978 # remove trailing .exe if any
16979 new_path="${new_path/%.exe/}"
16980
16981 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16982
16983 # First separate the path from the arguments. This will split at the first
16984 # space.
16985 complete="$FOUND_MAKE"
16986 path="${complete%% *}"
16987 tmp="$complete EOL"
16988 arguments="${tmp#* }"
16989
16990 # Input might be given as Windows format, start by converting to
16991 # unix format.
16992 new_path="$path"
16993
16994 windows_path="$new_path"
16995 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16996 unix_path=`$CYGPATH -u "$windows_path"`
16997 new_path="$unix_path"
16998 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16999 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17000 new_path="$unix_path"
17001 fi
17002
17003
17004 # Now try to locate executable using which
17005 new_path=`$WHICH "$new_path" 2> /dev/null`
17006
17007 if test "x$new_path" = x; then
17008 # Oops. Which didn't find the executable.
17009 # The splitting of arguments from the executable at a space might have been incorrect,
17010 # since paths with space are more likely in Windows. Give it another try with the whole
17011 # argument.
17012 path="$complete"
17013 arguments="EOL"
17014 new_path="$path"
17015
17016 windows_path="$new_path"
17017 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17018 unix_path=`$CYGPATH -u "$windows_path"`
17019 new_path="$unix_path"
17020 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17021 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17022 new_path="$unix_path"
17023 fi
17024
17025
17026 new_path=`$WHICH "$new_path" 2> /dev/null`
17027 # bat and cmd files are not always considered executable in MSYS causing which
17028 # to not find them
17029 if test "x$new_path" = x \
17030 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17031 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17032 new_path="$path"
17033
17034 windows_path="$new_path"
17035 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17036 unix_path=`$CYGPATH -u "$windows_path"`
17037 new_path="$unix_path"
17038 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17039 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17040 new_path="$unix_path"
17041 fi
17042
17043 fi
17044
17045 if test "x$new_path" = x; then
17046 # It's still not found. Now this is an unrecoverable error.
17047 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17048 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17049 has_space=`$ECHO "$complete" | $GREP " "`
17050 if test "x$has_space" != x; then
17051 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17052 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17053 fi
17054 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17055 fi
17056 fi
17057
17058 # Now new_path has a complete unix path to the binary
17059 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17060 # Keep paths in /bin as-is, but remove trailing .exe if any
17061 new_path="${new_path/%.exe/}"
17062 # Do not save /bin paths to all_fixpath_prefixes!
17063 else
17064 # Not in mixed or Windows style, start by that.
17065 new_path=`cmd //c echo $new_path`
17066
17067 input_path="$new_path"
17068 # Check if we need to convert this using DOS-style short mode. If the path
17069 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17070 # take no chances and rewrite it.
17071 # Note: m4 eats our [], so we need to use [ and ] instead.
17072 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17073 if test "x$has_forbidden_chars" != x; then
17074 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17075 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17076 fi
17077
17078 # Output is in $new_path
17079
17080 windows_path="$new_path"
17081 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17082 unix_path=`$CYGPATH -u "$windows_path"`
17083 new_path="$unix_path"
17084 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17085 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17086 new_path="$unix_path"
17087 fi
17088
17089 # remove trailing .exe if any
17090 new_path="${new_path/%.exe/}"
17091
17092 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17093 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17094 fi
17095
17096 else
17097 # We're on a unix platform. Hooray! :)
17098 # First separate the path from the arguments. This will split at the first
17099 # space.
17100 complete="$FOUND_MAKE"
17101 path="${complete%% *}"
17102 tmp="$complete EOL"
17103 arguments="${tmp#* }"
17104
17105 # Cannot rely on the command "which" here since it doesn't always work.
17106 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17107 if test -z "$is_absolute_path"; then
17108 # Path to executable is not absolute. Find it.
17109 IFS_save="$IFS"
17110 IFS=:
17111 for p in $PATH; do
17112 if test -f "$p/$path" && test -x "$p/$path"; then
17113 new_path="$p/$path"
17114 break
17115 fi
17116 done
17117 IFS="$IFS_save"
17118 else
17119 # This is an absolute path, we can use it without further modifications.
17120 new_path="$path"
17121 fi
17122
17123 if test "x$new_path" = x; then
17124 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17125 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17126 has_space=`$ECHO "$complete" | $GREP " "`
17127 if test "x$has_space" != x; then
17128 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17129 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17130 fi
17131 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17132 fi
17133 fi
17134
17135 # Now join together the path and the arguments once again
17136 if test "x$arguments" != xEOL; then
17137 new_complete="$new_path ${arguments% *}"
17138 else
17139 new_complete="$new_path"
17140 fi
17141
17142 if test "x$complete" != "x$new_complete"; then
17143 FOUND_MAKE="$new_complete"
17144 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17145 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17146 fi
17147 fi
17148
17149 fi
17150 fi
17151 fi
17152 fi
17153
17154 if test "x$FOUND_MAKE" = x; then
17155 for ac_prog in make
17156 do
17157 # Extract the first word of "$ac_prog", so it can be a program name with args.
17158 set dummy $ac_prog; ac_word=$2
17159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17160 $as_echo_n "checking for $ac_word... " >&6; }
17161 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
17162 $as_echo_n "(cached) " >&6
17163 else
17164 case $CHECK_TOOLSDIR_MAKE in
17165 [\\/]* | ?:[\\/]*)
17166 ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
17167 ;;
17168 *)
17169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17170 for as_dir in $PATH
17171 do
17172 IFS=$as_save_IFS
17173 test -z "$as_dir" && as_dir=.
17174 for ac_exec_ext in '' $ac_executable_extensions; do
17175 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17176 ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
17177 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17178 break 2
17179 fi
17180 done
17181 done
17182 IFS=$as_save_IFS
17183
17184 ;;
17185 esac
17186 fi
17187 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
17188 if test -n "$CHECK_TOOLSDIR_MAKE"; then
17189 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
17190 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
17191 else
17192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17193 $as_echo "no" >&6; }
17194 fi
17195
17196
17197 test -n "$CHECK_TOOLSDIR_MAKE" && break
17198 done
17199
17200
17201 MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
17202 DESCRIPTION="make in tools-dir"
17203
17204 # On Cygwin, we require a newer version of make than on other platforms
17205 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17206 MAKE_VERSION_EXPR="-e 4\."
17207 MAKE_REQUIRED_VERSION="4.0"
17208 else
17209 MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17210 MAKE_REQUIRED_VERSION="3.81"
17211 fi
17212
17213 if test "x$MAKE_CANDIDATE" != x; then
17214 { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17215 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17216 MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17217 IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17218 if test "x$IS_GNU_MAKE" = x; then
17219 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17220 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17221 else
17222 IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17223 if test "x$IS_MODERN_MAKE" = x; then
17224 { $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
17225 $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;}
17226 else
17227 if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17228 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17229 MAKE_EXPECTED_ENV='cygwin'
17230 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17231 MAKE_EXPECTED_ENV='msys'
17232 else
17233 as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17234 fi
17235 MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17236 IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17237 else
17238 # Not relevant for non-Windows
17239 IS_MAKE_CORRECT_ENV=true
17240 fi
17241 if test "x$IS_MAKE_CORRECT_ENV" = x; then
17242 { $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
17243 $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;}
17244 else
17245 FOUND_MAKE=$MAKE_CANDIDATE
17246
17247 # Only process if variable expands to non-empty
17248
17249 if test "x$FOUND_MAKE" != x; then
17250 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17251
17252 # First separate the path from the arguments. This will split at the first
17253 # space.
17254 complete="$FOUND_MAKE"
17255 path="${complete%% *}"
17256 tmp="$complete EOL"
17257 arguments="${tmp#* }"
17258
17259 # Input might be given as Windows format, start by converting to
17260 # unix format.
17261 new_path=`$CYGPATH -u "$path"`
17262
17263 # Now try to locate executable using which
17264 new_path=`$WHICH "$new_path" 2> /dev/null`
17265 # bat and cmd files are not always considered executable in cygwin causing which
17266 # to not find them
17267 if test "x$new_path" = x \
17268 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17269 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17270 new_path=`$CYGPATH -u "$path"`
17271 fi
17272 if test "x$new_path" = x; then
17273 # Oops. Which didn't find the executable.
17274 # The splitting of arguments from the executable at a space might have been incorrect,
17275 # since paths with space are more likely in Windows. Give it another try with the whole
17276 # argument.
17277 path="$complete"
17278 arguments="EOL"
17279 new_path=`$CYGPATH -u "$path"`
17280 new_path=`$WHICH "$new_path" 2> /dev/null`
17281 # bat and cmd files are not always considered executable in cygwin causing which
17282 # to not find them
17283 if test "x$new_path" = x \
17284 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17285 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17286 new_path=`$CYGPATH -u "$path"`
17287 fi
17288 if test "x$new_path" = x; then
17289 # It's still not found. Now this is an unrecoverable error.
17290 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17291 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17292 has_space=`$ECHO "$complete" | $GREP " "`
17293 if test "x$has_space" != x; then
17294 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17295 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17296 fi
17297 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17298 fi
17299 fi
17300
17301 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17302 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17303 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17304 # "foo.exe" is OK but "foo" is an error.
17305 #
17306 # This test is therefore slightly more accurate than "test -f" to check for file presence.
17307 # It is also a way to make sure we got the proper file name for the real test later on.
17308 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17309 if test "x$test_shortpath" = x; then
17310 # Short path failed, file does not exist as specified.
17311 # Try adding .exe or .cmd
17312 if test -f "${new_path}.exe"; then
17313 input_to_shortpath="${new_path}.exe"
17314 elif test -f "${new_path}.cmd"; then
17315 input_to_shortpath="${new_path}.cmd"
17316 else
17317 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17318 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17319 { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17320 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17321 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17322 fi
17323 else
17324 input_to_shortpath="$new_path"
17325 fi
17326
17327 # Call helper function which possibly converts this using DOS-style short mode.
17328 # If so, the updated path is stored in $new_path.
17329 new_path="$input_to_shortpath"
17330
17331 input_path="$input_to_shortpath"
17332 # Check if we need to convert this using DOS-style short mode. If the path
17333 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17334 # take no chances and rewrite it.
17335 # Note: m4 eats our [], so we need to use [ and ] instead.
17336 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17337 if test "x$has_forbidden_chars" != x; then
17338 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17339 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17340 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17341 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17342 # Going to short mode and back again did indeed matter. Since short mode is
17343 # case insensitive, let's make it lowercase to improve readability.
17344 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17345 # Now convert it back to Unix-style (cygpath)
17346 input_path=`$CYGPATH -u "$shortmode_path"`
17347 new_path="$input_path"
17348 fi
17349 fi
17350
17351 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17352 if test "x$test_cygdrive_prefix" = x; then
17353 # As a simple fix, exclude /usr/bin since it's not a real path.
17354 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17355 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17356 # a path prefixed by /cygdrive for fixpath to work.
17357 new_path="$CYGWIN_ROOT_PATH$input_path"
17358 fi
17359 fi
17360
17361 # remove trailing .exe if any
17362 new_path="${new_path/%.exe/}"
17363
17364 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17365
17366 # First separate the path from the arguments. This will split at the first
17367 # space.
17368 complete="$FOUND_MAKE"
17369 path="${complete%% *}"
17370 tmp="$complete EOL"
17371 arguments="${tmp#* }"
17372
17373 # Input might be given as Windows format, start by converting to
17374 # unix format.
17375 new_path="$path"
17376
17377 windows_path="$new_path"
17378 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17379 unix_path=`$CYGPATH -u "$windows_path"`
17380 new_path="$unix_path"
17381 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17382 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17383 new_path="$unix_path"
17384 fi
17385
17386
17387 # Now try to locate executable using which
17388 new_path=`$WHICH "$new_path" 2> /dev/null`
17389
17390 if test "x$new_path" = x; then
17391 # Oops. Which didn't find the executable.
17392 # The splitting of arguments from the executable at a space might have been incorrect,
17393 # since paths with space are more likely in Windows. Give it another try with the whole
17394 # argument.
17395 path="$complete"
17396 arguments="EOL"
17397 new_path="$path"
17398
17399 windows_path="$new_path"
17400 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17401 unix_path=`$CYGPATH -u "$windows_path"`
17402 new_path="$unix_path"
17403 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17404 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17405 new_path="$unix_path"
17406 fi
17407
17408
17409 new_path=`$WHICH "$new_path" 2> /dev/null`
17410 # bat and cmd files are not always considered executable in MSYS causing which
17411 # to not find them
17412 if test "x$new_path" = x \
17413 && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17414 && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17415 new_path="$path"
17416
17417 windows_path="$new_path"
17418 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17419 unix_path=`$CYGPATH -u "$windows_path"`
17420 new_path="$unix_path"
17421 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17422 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17423 new_path="$unix_path"
17424 fi
17425
17426 fi
17427
17428 if test "x$new_path" = x; then
17429 # It's still not found. Now this is an unrecoverable error.
17430 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17431 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17432 has_space=`$ECHO "$complete" | $GREP " "`
17433 if test "x$has_space" != x; then
17434 { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17435 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17436 fi
17437 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17438 fi
17439 fi
17440
17441 # Now new_path has a complete unix path to the binary
17442 if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17443 # Keep paths in /bin as-is, but remove trailing .exe if any
17444 new_path="${new_path/%.exe/}"
17445 # Do not save /bin paths to all_fixpath_prefixes!
17446 else
17447 # Not in mixed or Windows style, start by that.
17448 new_path=`cmd //c echo $new_path`
17449
17450 input_path="$new_path"
17451 # Check if we need to convert this using DOS-style short mode. If the path
17452 # contains just simple characters, use it. Otherwise (spaces, weird characters),
17453 # take no chances and rewrite it.
17454 # Note: m4 eats our [], so we need to use [ and ] instead.
17455 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17456 if test "x$has_forbidden_chars" != x; then
17457 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17458 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17459 fi
17460
17461 # Output is in $new_path
17462
17463 windows_path="$new_path"
17464 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17465 unix_path=`$CYGPATH -u "$windows_path"`
17466 new_path="$unix_path"
17467 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17468 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17469 new_path="$unix_path"
17470 fi
17471
17472 # remove trailing .exe if any
17473 new_path="${new_path/%.exe/}"
17474
17475 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17476 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17477 fi
17478
17479 else
17480 # We're on a unix platform. Hooray! :)
17481 # First separate the path from the arguments. This will split at the first
17482 # space.
17483 complete="$FOUND_MAKE"
17484 path="${complete%% *}"
17485 tmp="$complete EOL"
17486 arguments="${tmp#* }"
17487
17488 # Cannot rely on the command "which" here since it doesn't always work.
17489 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17490 if test -z "$is_absolute_path"; then
17491 # Path to executable is not absolute. Find it.
17492 IFS_save="$IFS"
17493 IFS=:
17494 for p in $PATH; do
17495 if test -f "$p/$path" && test -x "$p/$path"; then
17496 new_path="$p/$path"
17497 break
17498 fi
17499 done
17500 IFS="$IFS_save"
17501 else
17502 # This is an absolute path, we can use it without further modifications.
17503 new_path="$path"
17504 fi
17505
17506 if test "x$new_path" = x; then
17507 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17508 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17509 has_space=`$ECHO "$complete" | $GREP " "`
17510 if test "x$has_space" != x; then
17511 { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17512 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17513 fi
17514 as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17515 fi
17516 fi
17517
17518 # Now join together the path and the arguments once again
17519 if test "x$arguments" != xEOL; then
17520 new_complete="$new_path ${arguments% *}"
17521 else
17522 new_complete="$new_path"
17523 fi
17524
17525 if test "x$complete" != "x$new_complete"; then
17526 FOUND_MAKE="$new_complete"
17527 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17528 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17529 fi
17530 fi
17531
17532 fi
17533 fi
17534 fi
17535 fi
17536
17537 fi
17538 PATH=$OLD_PATH
17539 fi
17540 fi
17541
17542 if test "x$FOUND_MAKE" = x; then
17543 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
17544 fi
17545 fi
17546
17547 MAKE=$FOUND_MAKE
17548
17549 { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17550 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17551
17552
17553 # Check if make supports the output sync option and if so, setup using it.
17554 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
17555 $as_echo_n "checking if make --output-sync is supported... " >&6; }
17556 if $MAKE --version -O > /dev/null 2>&1; then
17557 OUTPUT_SYNC_SUPPORTED=true
17558 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17559 $as_echo "yes" >&6; }
17560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
17561 $as_echo_n "checking for output-sync value... " >&6; }
17562
17563 # Check whether --with-output-sync was given.
17564 if test "${with_output_sync+set}" = set; then :
17565 withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
17566 fi
17567
17568 if test "x$OUTPUT_SYNC" = "x"; then
17569 OUTPUT_SYNC=none
17570 fi
17571 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
17572 $as_echo "$OUTPUT_SYNC" >&6; }
17573 if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
17574 as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
17575 fi
17576 else
17577 OUTPUT_SYNC_SUPPORTED=false
17578 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17579 $as_echo "no" >&6; }
17580 fi
17581
17582
17583
17584
17585
17586
17587 # Test if find supports -delete
17588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17589 $as_echo_n "checking if find supports -delete... " >&6; }
17590 FIND_DELETE="-delete"
17591
17592 DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17593
17594 echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17595
17596 TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17597 if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17598 # No, it does not.
17599 rm $DELETEDIR/TestIfFindSupportsDelete
17600 if test "x$OPENJDK_TARGET_OS" = "xaix"; then
17601 # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
17602 FIND_DELETE="-print | xargs rm"
17603 else
17604 FIND_DELETE="-exec rm \{\} \+"
17605 fi
17606 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17607 $as_echo "no" >&6; }
17608 else
17609 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17610 $as_echo "yes" >&6; }
17611 fi
17612 rmdir $DELETEDIR
17613
17614
17615
17616 # These tools might not be installed by default,
17617 # need hint on how to install them.
17618
17619
17620
17621 # Publish this variable in the help.
17622
17623
17624 if test "x$UNZIP" = x; then
17625 # The variable is not set by user, try to locate tool using the code snippet
17626 for ac_prog in unzip
17627 do
17628 # Extract the first word of "$ac_prog", so it can be a program name with args.
17629 set dummy $ac_prog; ac_word=$2
17630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17631 $as_echo_n "checking for $ac_word... " >&6; }
17632 if ${ac_cv_path_UNZIP+:} false; then :
17633 $as_echo_n "(cached) " >&6
17634 else
17635 case $UNZIP in
17636 [\\/]* | ?:[\\/]*)
17637 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17638 ;;
17639 *)
17640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17641 for as_dir in $PATH
17642 do
17643 IFS=$as_save_IFS
17644 test -z "$as_dir" && as_dir=.
17645 for ac_exec_ext in '' $ac_executable_extensions; do
17646 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17647 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17648 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17649 break 2
17650 fi
17651 done
17652 done
17653 IFS=$as_save_IFS
17654
17655 ;;
17656 esac
17657 fi
17658 UNZIP=$ac_cv_path_UNZIP
17659 if test -n "$UNZIP"; then
17660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17661 $as_echo "$UNZIP" >&6; }
17662 else
17663 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17664 $as_echo "no" >&6; }
17665 fi
17666
17667
17668 test -n "$UNZIP" && break
17669 done
17670
17671 else
17672 # The variable is set, but is it from the command line or the environment?
17673
17674 # Try to remove the string !UNZIP! from our list.
17675 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17676 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17677 # If it failed, the variable was not from the command line. Ignore it,
17678 # but warn the user (except for BASH, which is always set by the calling BASH).
17679 if test "xUNZIP" != xBASH; then
17680 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17681 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17682 fi
17683 # Try to locate tool using the code snippet
17684 for ac_prog in unzip
17685 do
17686 # Extract the first word of "$ac_prog", so it can be a program name with args.
17687 set dummy $ac_prog; ac_word=$2
17688 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17689 $as_echo_n "checking for $ac_word... " >&6; }
17690 if ${ac_cv_path_UNZIP+:} false; then :
17691 $as_echo_n "(cached) " >&6
17692 else
17693 case $UNZIP in
17694 [\\/]* | ?:[\\/]*)
17695 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17696 ;;
17697 *)
17698 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17699 for as_dir in $PATH
17700 do
17701 IFS=$as_save_IFS
17702 test -z "$as_dir" && as_dir=.
17703 for ac_exec_ext in '' $ac_executable_extensions; do
17704 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17705 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17706 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17707 break 2
17708 fi
17709 done
17710 done
17711 IFS=$as_save_IFS
17712
17713 ;;
17714 esac
17715 fi
17716 UNZIP=$ac_cv_path_UNZIP
17717 if test -n "$UNZIP"; then
17718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17719 $as_echo "$UNZIP" >&6; }
17720 else
17721 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17722 $as_echo "no" >&6; }
17723 fi
17724
17725
17726 test -n "$UNZIP" && break
17727 done
17728
17729 else
17730 # If it succeeded, then it was overridden by the user. We will use it
17731 # for the tool.
17732
17733 # First remove it from the list of overridden variables, so we can test
17734 # for unknown variables in the end.
17735 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17736
17737 # Check if the provided tool contains a complete path.
17738 tool_specified="$UNZIP"
17739 tool_basename="${tool_specified##*/}"
17740 if test "x$tool_basename" = "x$tool_specified"; then
17741 # A command without a complete path is provided, search $PATH.
17742 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17743 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17744 # Extract the first word of "$tool_basename", so it can be a program name with args.
17745 set dummy $tool_basename; ac_word=$2
17746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17747 $as_echo_n "checking for $ac_word... " >&6; }
17748 if ${ac_cv_path_UNZIP+:} false; then :
17749 $as_echo_n "(cached) " >&6
17750 else
17751 case $UNZIP in
17752 [\\/]* | ?:[\\/]*)
17753 ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17754 ;;
17755 *)
17756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17757 for as_dir in $PATH
17758 do
17759 IFS=$as_save_IFS
17760 test -z "$as_dir" && as_dir=.
17761 for ac_exec_ext in '' $ac_executable_extensions; do
17762 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17763 ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17764 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17765 break 2
17766 fi
17767 done
17768 done
17769 IFS=$as_save_IFS
17770
17771 ;;
17772 esac
17773 fi
17774 UNZIP=$ac_cv_path_UNZIP
17775 if test -n "$UNZIP"; then
17776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17777 $as_echo "$UNZIP" >&6; }
17778 else
17779 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17780 $as_echo "no" >&6; }
17781 fi
17782
17783
17784 if test "x$UNZIP" = x; then
17785 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17786 fi
17787 else
17788 # Otherwise we believe it is a complete path. Use it as it is.
17789 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17790 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17791 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17792 $as_echo_n "checking for UNZIP... " >&6; }
17793 if test ! -x "$tool_specified"; then
17794 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17795 $as_echo "not found" >&6; }
17796 as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17797 fi
17798 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17799 $as_echo "$tool_specified" >&6; }
17800 fi
17801 fi
17802 fi
17803
17804
17805
17806 if test "x$UNZIP" = x; then
17807 as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17808 fi
17809
17810
17811
17812
17813
17814 # Publish this variable in the help.
17815
17816
17817 if test "x$ZIP" = x; then
17818 # The variable is not set by user, try to locate tool using the code snippet
17819 for ac_prog in zip
17820 do
17821 # Extract the first word of "$ac_prog", so it can be a program name with args.
17822 set dummy $ac_prog; ac_word=$2
17823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17824 $as_echo_n "checking for $ac_word... " >&6; }
17825 if ${ac_cv_path_ZIP+:} false; then :
17826 $as_echo_n "(cached) " >&6
17827 else
17828 case $ZIP in
17829 [\\/]* | ?:[\\/]*)
17830 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17831 ;;
17832 *)
17833 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17834 for as_dir in $PATH
17835 do
17836 IFS=$as_save_IFS
17837 test -z "$as_dir" && as_dir=.
17838 for ac_exec_ext in '' $ac_executable_extensions; do
17839 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17840 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17841 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17842 break 2
17843 fi
17844 done
17845 done
17846 IFS=$as_save_IFS
17847
17848 ;;
17849 esac
17850 fi
17851 ZIP=$ac_cv_path_ZIP
17852 if test -n "$ZIP"; then
17853 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17854 $as_echo "$ZIP" >&6; }
17855 else
17856 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17857 $as_echo "no" >&6; }
17858 fi
17859
17860
17861 test -n "$ZIP" && break
17862 done
17863
17864 else
17865 # The variable is set, but is it from the command line or the environment?
17866
17867 # Try to remove the string !ZIP! from our list.
17868 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17869 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17870 # If it failed, the variable was not from the command line. Ignore it,
17871 # but warn the user (except for BASH, which is always set by the calling BASH).
17872 if test "xZIP" != xBASH; then
17873 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17874 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17875 fi
17876 # Try to locate tool using the code snippet
17877 for ac_prog in zip
17878 do
17879 # Extract the first word of "$ac_prog", so it can be a program name with args.
17880 set dummy $ac_prog; ac_word=$2
17881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17882 $as_echo_n "checking for $ac_word... " >&6; }
17883 if ${ac_cv_path_ZIP+:} false; then :
17884 $as_echo_n "(cached) " >&6
17885 else
17886 case $ZIP in
17887 [\\/]* | ?:[\\/]*)
17888 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17889 ;;
17890 *)
17891 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17892 for as_dir in $PATH
17893 do
17894 IFS=$as_save_IFS
17895 test -z "$as_dir" && as_dir=.
17896 for ac_exec_ext in '' $ac_executable_extensions; do
17897 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17898 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17899 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17900 break 2
17901 fi
17902 done
17903 done
17904 IFS=$as_save_IFS
17905
17906 ;;
17907 esac
17908 fi
17909 ZIP=$ac_cv_path_ZIP
17910 if test -n "$ZIP"; then
17911 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17912 $as_echo "$ZIP" >&6; }
17913 else
17914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17915 $as_echo "no" >&6; }
17916 fi
17917
17918
17919 test -n "$ZIP" && break
17920 done
17921
17922 else
17923 # If it succeeded, then it was overridden by the user. We will use it
17924 # for the tool.
17925
17926 # First remove it from the list of overridden variables, so we can test
17927 # for unknown variables in the end.
17928 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17929
17930 # Check if the provided tool contains a complete path.
17931 tool_specified="$ZIP"
17932 tool_basename="${tool_specified##*/}"
17933 if test "x$tool_basename" = "x$tool_specified"; then
17934 # A command without a complete path is provided, search $PATH.
17935 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17936 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17937 # Extract the first word of "$tool_basename", so it can be a program name with args.
17938 set dummy $tool_basename; ac_word=$2
17939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17940 $as_echo_n "checking for $ac_word... " >&6; }
17941 if ${ac_cv_path_ZIP+:} false; then :
17942 $as_echo_n "(cached) " >&6
17943 else
17944 case $ZIP in
17945 [\\/]* | ?:[\\/]*)
17946 ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17947 ;;
17948 *)
17949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17950 for as_dir in $PATH
17951 do
17952 IFS=$as_save_IFS
17953 test -z "$as_dir" && as_dir=.
17954 for ac_exec_ext in '' $ac_executable_extensions; do
17955 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17956 ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17957 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17958 break 2
17959 fi
17960 done
17961 done
17962 IFS=$as_save_IFS
17963
17964 ;;
17965 esac
17966 fi
17967 ZIP=$ac_cv_path_ZIP
17968 if test -n "$ZIP"; then
17969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17970 $as_echo "$ZIP" >&6; }
17971 else
17972 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17973 $as_echo "no" >&6; }
17974 fi
17975
17976
17977 if test "x$ZIP" = x; then
17978 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17979 fi
17980 else
17981 # Otherwise we believe it is a complete path. Use it as it is.
17982 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17983 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17985 $as_echo_n "checking for ZIP... " >&6; }
17986 if test ! -x "$tool_specified"; then
17987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17988 $as_echo "not found" >&6; }
17989 as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17990 fi
17991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17992 $as_echo "$tool_specified" >&6; }
17993 fi
17994 fi
17995 fi
17996
17997
17998
17999 if test "x$ZIP" = x; then
18000 as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
18001 fi
18002
18003
18004
18005 # Non-required basic tools
18006
18007
18008
18009 # Publish this variable in the help.
18010
18011
18012 if test "x$LDD" = x; then
18013 # The variable is not set by user, try to locate tool using the code snippet
18014 for ac_prog in ldd
18015 do
18016 # Extract the first word of "$ac_prog", so it can be a program name with args.
18017 set dummy $ac_prog; ac_word=$2
18018 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18019 $as_echo_n "checking for $ac_word... " >&6; }
18020 if ${ac_cv_path_LDD+:} false; then :
18021 $as_echo_n "(cached) " >&6
18022 else
18023 case $LDD in
18024 [\\/]* | ?:[\\/]*)
18025 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
18026 ;;
18027 *)
18028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18029 for as_dir in $PATH
18030 do
18031 IFS=$as_save_IFS
18032 test -z "$as_dir" && as_dir=.
18033 for ac_exec_ext in '' $ac_executable_extensions; do
18034 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18035 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
18036 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18037 break 2
18038 fi
18039 done
18040 done
18041 IFS=$as_save_IFS
18042
18043 ;;
18044 esac
18045 fi
18046 LDD=$ac_cv_path_LDD
18047 if test -n "$LDD"; then
18048 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
18049 $as_echo "$LDD" >&6; }
18050 else
18051 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18052 $as_echo "no" >&6; }
18053 fi
18054
18055
18056 test -n "$LDD" && break
18057 done
18058
18059 else
18060 # The variable is set, but is it from the command line or the environment?
18061
18062 # Try to remove the string !LDD! from our list.
18063 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
18064 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18065 # If it failed, the variable was not from the command line. Ignore it,
18066 # but warn the user (except for BASH, which is always set by the calling BASH).
18067 if test "xLDD" != xBASH; then
18068 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
18069 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
18070 fi
18071 # Try to locate tool using the code snippet
18072 for ac_prog in ldd
18073 do
18074 # Extract the first word of "$ac_prog", so it can be a program name with args.
18075 set dummy $ac_prog; ac_word=$2
18076 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18077 $as_echo_n "checking for $ac_word... " >&6; }
18078 if ${ac_cv_path_LDD+:} false; then :
18079 $as_echo_n "(cached) " >&6
18080 else
18081 case $LDD in
18082 [\\/]* | ?:[\\/]*)
18083 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
18084 ;;
18085 *)
18086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18087 for as_dir in $PATH
18088 do
18089 IFS=$as_save_IFS
18090 test -z "$as_dir" && as_dir=.
18091 for ac_exec_ext in '' $ac_executable_extensions; do
18092 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18093 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
18094 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18095 break 2
18096 fi
18097 done
18098 done
18099 IFS=$as_save_IFS
18100
18101 ;;
18102 esac
18103 fi
18104 LDD=$ac_cv_path_LDD
18105 if test -n "$LDD"; then
18106 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
18107 $as_echo "$LDD" >&6; }
18108 else
18109 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18110 $as_echo "no" >&6; }
18111 fi
18112
18113
18114 test -n "$LDD" && break
18115 done
18116
18117 else
18118 # If it succeeded, then it was overridden by the user. We will use it
18119 # for the tool.
18120
18121 # First remove it from the list of overridden variables, so we can test
18122 # for unknown variables in the end.
18123 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18124
18125 # Check if the provided tool contains a complete path.
18126 tool_specified="$LDD"
18127 tool_basename="${tool_specified##*/}"
18128 if test "x$tool_basename" = "x$tool_specified"; then
18129 # A command without a complete path is provided, search $PATH.
18130 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
18131 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
18132 # Extract the first word of "$tool_basename", so it can be a program name with args.
18133 set dummy $tool_basename; ac_word=$2
18134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18135 $as_echo_n "checking for $ac_word... " >&6; }
18136 if ${ac_cv_path_LDD+:} false; then :
18137 $as_echo_n "(cached) " >&6
18138 else
18139 case $LDD in
18140 [\\/]* | ?:[\\/]*)
18141 ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
18142 ;;
18143 *)
18144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18145 for as_dir in $PATH
18146 do
18147 IFS=$as_save_IFS
18148 test -z "$as_dir" && as_dir=.
18149 for ac_exec_ext in '' $ac_executable_extensions; do
18150 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18151 ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
18152 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18153 break 2
18154 fi
18155 done
18156 done
18157 IFS=$as_save_IFS
18158
18159 ;;
18160 esac
18161 fi
18162 LDD=$ac_cv_path_LDD
18163 if test -n "$LDD"; then
18164 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
18165 $as_echo "$LDD" >&6; }
18166 else
18167 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18168 $as_echo "no" >&6; }
18169 fi
18170
18171
18172 if test "x$LDD" = x; then
18173 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18174 fi
18175 else
18176 # Otherwise we believe it is a complete path. Use it as it is.
18177 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
18178 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
18179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
18180 $as_echo_n "checking for LDD... " >&6; }
18181 if test ! -x "$tool_specified"; then
18182 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18183 $as_echo "not found" >&6; }
18184 as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
18185 fi
18186 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18187 $as_echo "$tool_specified" >&6; }
18188 fi
18189 fi
18190 fi
18191
18192
18193 if test "x$LDD" = "x"; then
18194 # List shared lib dependencies is used for
18195 # debug output and checking for forbidden dependencies.
18196 # We can build without it.
18197 LDD="true"
18198 fi
18199
18200
18201 # Publish this variable in the help.
18202
18203
18204 if test "x$OTOOL" = x; then
18205 # The variable is not set by user, try to locate tool using the code snippet
18206 for ac_prog in otool
18207 do
18208 # Extract the first word of "$ac_prog", so it can be a program name with args.
18209 set dummy $ac_prog; ac_word=$2
18210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18211 $as_echo_n "checking for $ac_word... " >&6; }
18212 if ${ac_cv_path_OTOOL+:} false; then :
18213 $as_echo_n "(cached) " >&6
18214 else
18215 case $OTOOL in
18216 [\\/]* | ?:[\\/]*)
18217 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18218 ;;
18219 *)
18220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18221 for as_dir in $PATH
18222 do
18223 IFS=$as_save_IFS
18224 test -z "$as_dir" && as_dir=.
18225 for ac_exec_ext in '' $ac_executable_extensions; do
18226 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18227 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18228 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18229 break 2
18230 fi
18231 done
18232 done
18233 IFS=$as_save_IFS
18234
18235 ;;
18236 esac
18237 fi
18238 OTOOL=$ac_cv_path_OTOOL
18239 if test -n "$OTOOL"; then
18240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18241 $as_echo "$OTOOL" >&6; }
18242 else
18243 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18244 $as_echo "no" >&6; }
18245 fi
18246
18247
18248 test -n "$OTOOL" && break
18249 done
18250
18251 else
18252 # The variable is set, but is it from the command line or the environment?
18253
18254 # Try to remove the string !OTOOL! from our list.
18255 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
18256 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18257 # If it failed, the variable was not from the command line. Ignore it,
18258 # but warn the user (except for BASH, which is always set by the calling BASH).
18259 if test "xOTOOL" != xBASH; then
18260 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
18261 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
18262 fi
18263 # Try to locate tool using the code snippet
18264 for ac_prog in otool
18265 do
18266 # Extract the first word of "$ac_prog", so it can be a program name with args.
18267 set dummy $ac_prog; ac_word=$2
18268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18269 $as_echo_n "checking for $ac_word... " >&6; }
18270 if ${ac_cv_path_OTOOL+:} false; then :
18271 $as_echo_n "(cached) " >&6
18272 else
18273 case $OTOOL in
18274 [\\/]* | ?:[\\/]*)
18275 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18276 ;;
18277 *)
18278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18279 for as_dir in $PATH
18280 do
18281 IFS=$as_save_IFS
18282 test -z "$as_dir" && as_dir=.
18283 for ac_exec_ext in '' $ac_executable_extensions; do
18284 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18285 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18286 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18287 break 2
18288 fi
18289 done
18290 done
18291 IFS=$as_save_IFS
18292
18293 ;;
18294 esac
18295 fi
18296 OTOOL=$ac_cv_path_OTOOL
18297 if test -n "$OTOOL"; then
18298 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18299 $as_echo "$OTOOL" >&6; }
18300 else
18301 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18302 $as_echo "no" >&6; }
18303 fi
18304
18305
18306 test -n "$OTOOL" && break
18307 done
18308
18309 else
18310 # If it succeeded, then it was overridden by the user. We will use it
18311 # for the tool.
18312
18313 # First remove it from the list of overridden variables, so we can test
18314 # for unknown variables in the end.
18315 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18316
18317 # Check if the provided tool contains a complete path.
18318 tool_specified="$OTOOL"
18319 tool_basename="${tool_specified##*/}"
18320 if test "x$tool_basename" = "x$tool_specified"; then
18321 # A command without a complete path is provided, search $PATH.
18322 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
18323 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
18324 # Extract the first word of "$tool_basename", so it can be a program name with args.
18325 set dummy $tool_basename; ac_word=$2
18326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18327 $as_echo_n "checking for $ac_word... " >&6; }
18328 if ${ac_cv_path_OTOOL+:} false; then :
18329 $as_echo_n "(cached) " >&6
18330 else
18331 case $OTOOL in
18332 [\\/]* | ?:[\\/]*)
18333 ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18334 ;;
18335 *)
18336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18337 for as_dir in $PATH
18338 do
18339 IFS=$as_save_IFS
18340 test -z "$as_dir" && as_dir=.
18341 for ac_exec_ext in '' $ac_executable_extensions; do
18342 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18343 ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18344 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18345 break 2
18346 fi
18347 done
18348 done
18349 IFS=$as_save_IFS
18350
18351 ;;
18352 esac
18353 fi
18354 OTOOL=$ac_cv_path_OTOOL
18355 if test -n "$OTOOL"; then
18356 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18357 $as_echo "$OTOOL" >&6; }
18358 else
18359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18360 $as_echo "no" >&6; }
18361 fi
18362
18363
18364 if test "x$OTOOL" = x; then
18365 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18366 fi
18367 else
18368 # Otherwise we believe it is a complete path. Use it as it is.
18369 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
18370 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
18371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
18372 $as_echo_n "checking for OTOOL... " >&6; }
18373 if test ! -x "$tool_specified"; then
18374 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18375 $as_echo "not found" >&6; }
18376 as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
18377 fi
18378 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18379 $as_echo "$tool_specified" >&6; }
18380 fi
18381 fi
18382 fi
18383
18384
18385 if test "x$OTOOL" = "x"; then
18386 OTOOL="true"
18387 fi
18388
18389
18390 # Publish this variable in the help.
18391
18392
18393 if test "x$READELF" = x; then
18394 # The variable is not set by user, try to locate tool using the code snippet
18395 for ac_prog in greadelf readelf
18396 do
18397 # Extract the first word of "$ac_prog", so it can be a program name with args.
18398 set dummy $ac_prog; ac_word=$2
18399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18400 $as_echo_n "checking for $ac_word... " >&6; }
18401 if ${ac_cv_path_READELF+:} false; then :
18402 $as_echo_n "(cached) " >&6
18403 else
18404 case $READELF in
18405 [\\/]* | ?:[\\/]*)
18406 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18407 ;;
18408 *)
18409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18410 for as_dir in $PATH
18411 do
18412 IFS=$as_save_IFS
18413 test -z "$as_dir" && as_dir=.
18414 for ac_exec_ext in '' $ac_executable_extensions; do
18415 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18416 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18417 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18418 break 2
18419 fi
18420 done
18421 done
18422 IFS=$as_save_IFS
18423
18424 ;;
18425 esac
18426 fi
18427 READELF=$ac_cv_path_READELF
18428 if test -n "$READELF"; then
18429 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18430 $as_echo "$READELF" >&6; }
18431 else
18432 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18433 $as_echo "no" >&6; }
18434 fi
18435
18436
18437 test -n "$READELF" && break
18438 done
18439
18440 else
18441 # The variable is set, but is it from the command line or the environment?
18442
18443 # Try to remove the string !READELF! from our list.
18444 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
18445 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18446 # If it failed, the variable was not from the command line. Ignore it,
18447 # but warn the user (except for BASH, which is always set by the calling BASH).
18448 if test "xREADELF" != xBASH; then
18449 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
18450 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
18451 fi
18452 # Try to locate tool using the code snippet
18453 for ac_prog in greadelf readelf
18454 do
18455 # Extract the first word of "$ac_prog", so it can be a program name with args.
18456 set dummy $ac_prog; ac_word=$2
18457 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18458 $as_echo_n "checking for $ac_word... " >&6; }
18459 if ${ac_cv_path_READELF+:} false; then :
18460 $as_echo_n "(cached) " >&6
18461 else
18462 case $READELF in
18463 [\\/]* | ?:[\\/]*)
18464 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18465 ;;
18466 *)
18467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18468 for as_dir in $PATH
18469 do
18470 IFS=$as_save_IFS
18471 test -z "$as_dir" && as_dir=.
18472 for ac_exec_ext in '' $ac_executable_extensions; do
18473 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18474 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18475 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18476 break 2
18477 fi
18478 done
18479 done
18480 IFS=$as_save_IFS
18481
18482 ;;
18483 esac
18484 fi
18485 READELF=$ac_cv_path_READELF
18486 if test -n "$READELF"; then
18487 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18488 $as_echo "$READELF" >&6; }
18489 else
18490 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18491 $as_echo "no" >&6; }
18492 fi
18493
18494
18495 test -n "$READELF" && break
18496 done
18497
18498 else
18499 # If it succeeded, then it was overridden by the user. We will use it
18500 # for the tool.
18501
18502 # First remove it from the list of overridden variables, so we can test
18503 # for unknown variables in the end.
18504 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18505
18506 # Check if the provided tool contains a complete path.
18507 tool_specified="$READELF"
18508 tool_basename="${tool_specified##*/}"
18509 if test "x$tool_basename" = "x$tool_specified"; then
18510 # A command without a complete path is provided, search $PATH.
18511 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
18512 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
18513 # Extract the first word of "$tool_basename", so it can be a program name with args.
18514 set dummy $tool_basename; ac_word=$2
18515 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18516 $as_echo_n "checking for $ac_word... " >&6; }
18517 if ${ac_cv_path_READELF+:} false; then :
18518 $as_echo_n "(cached) " >&6
18519 else
18520 case $READELF in
18521 [\\/]* | ?:[\\/]*)
18522 ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18523 ;;
18524 *)
18525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18526 for as_dir in $PATH
18527 do
18528 IFS=$as_save_IFS
18529 test -z "$as_dir" && as_dir=.
18530 for ac_exec_ext in '' $ac_executable_extensions; do
18531 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18532 ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18533 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18534 break 2
18535 fi
18536 done
18537 done
18538 IFS=$as_save_IFS
18539
18540 ;;
18541 esac
18542 fi
18543 READELF=$ac_cv_path_READELF
18544 if test -n "$READELF"; then
18545 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18546 $as_echo "$READELF" >&6; }
18547 else
18548 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18549 $as_echo "no" >&6; }
18550 fi
18551
18552
18553 if test "x$READELF" = x; then
18554 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18555 fi
18556 else
18557 # Otherwise we believe it is a complete path. Use it as it is.
18558 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18559 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18561 $as_echo_n "checking for READELF... " >&6; }
18562 if test ! -x "$tool_specified"; then
18563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18564 $as_echo "not found" >&6; }
18565 as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18566 fi
18567 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18568 $as_echo "$tool_specified" >&6; }
18569 fi
18570 fi
18571 fi
18572
18573
18574
18575
18576 # Publish this variable in the help.
18577
18578
18579 if test "x$HG" = x; then
18580 # The variable is not set by user, try to locate tool using the code snippet
18581 for ac_prog in hg
18582 do
18583 # Extract the first word of "$ac_prog", so it can be a program name with args.
18584 set dummy $ac_prog; ac_word=$2
18585 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18586 $as_echo_n "checking for $ac_word... " >&6; }
18587 if ${ac_cv_path_HG+:} false; then :
18588 $as_echo_n "(cached) " >&6
18589 else
18590 case $HG in
18591 [\\/]* | ?:[\\/]*)
18592 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18593 ;;
18594 *)
18595 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18596 for as_dir in $PATH
18597 do
18598 IFS=$as_save_IFS
18599 test -z "$as_dir" && as_dir=.
18600 for ac_exec_ext in '' $ac_executable_extensions; do
18601 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18602 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18603 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18604 break 2
18605 fi
18606 done
18607 done
18608 IFS=$as_save_IFS
18609
18610 ;;
18611 esac
18612 fi
18613 HG=$ac_cv_path_HG
18614 if test -n "$HG"; then
18615 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18616 $as_echo "$HG" >&6; }
18617 else
18618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18619 $as_echo "no" >&6; }
18620 fi
18621
18622
18623 test -n "$HG" && break
18624 done
18625
18626 else
18627 # The variable is set, but is it from the command line or the environment?
18628
18629 # Try to remove the string !HG! from our list.
18630 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18631 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18632 # If it failed, the variable was not from the command line. Ignore it,
18633 # but warn the user (except for BASH, which is always set by the calling BASH).
18634 if test "xHG" != xBASH; then
18635 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18636 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18637 fi
18638 # Try to locate tool using the code snippet
18639 for ac_prog in hg
18640 do
18641 # Extract the first word of "$ac_prog", so it can be a program name with args.
18642 set dummy $ac_prog; ac_word=$2
18643 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18644 $as_echo_n "checking for $ac_word... " >&6; }
18645 if ${ac_cv_path_HG+:} false; then :
18646 $as_echo_n "(cached) " >&6
18647 else
18648 case $HG in
18649 [\\/]* | ?:[\\/]*)
18650 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18651 ;;
18652 *)
18653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18654 for as_dir in $PATH
18655 do
18656 IFS=$as_save_IFS
18657 test -z "$as_dir" && as_dir=.
18658 for ac_exec_ext in '' $ac_executable_extensions; do
18659 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18660 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18661 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18662 break 2
18663 fi
18664 done
18665 done
18666 IFS=$as_save_IFS
18667
18668 ;;
18669 esac
18670 fi
18671 HG=$ac_cv_path_HG
18672 if test -n "$HG"; then
18673 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18674 $as_echo "$HG" >&6; }
18675 else
18676 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18677 $as_echo "no" >&6; }
18678 fi
18679
18680
18681 test -n "$HG" && break
18682 done
18683
18684 else
18685 # If it succeeded, then it was overridden by the user. We will use it
18686 # for the tool.
18687
18688 # First remove it from the list of overridden variables, so we can test
18689 # for unknown variables in the end.
18690 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18691
18692 # Check if the provided tool contains a complete path.
18693 tool_specified="$HG"
18694 tool_basename="${tool_specified##*/}"
18695 if test "x$tool_basename" = "x$tool_specified"; then
18696 # A command without a complete path is provided, search $PATH.
18697 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18698 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18699 # Extract the first word of "$tool_basename", so it can be a program name with args.
18700 set dummy $tool_basename; ac_word=$2
18701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18702 $as_echo_n "checking for $ac_word... " >&6; }
18703 if ${ac_cv_path_HG+:} false; then :
18704 $as_echo_n "(cached) " >&6
18705 else
18706 case $HG in
18707 [\\/]* | ?:[\\/]*)
18708 ac_cv_path_HG="$HG" # Let the user override the test with a path.
18709 ;;
18710 *)
18711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18712 for as_dir in $PATH
18713 do
18714 IFS=$as_save_IFS
18715 test -z "$as_dir" && as_dir=.
18716 for ac_exec_ext in '' $ac_executable_extensions; do
18717 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18718 ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18719 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18720 break 2
18721 fi
18722 done
18723 done
18724 IFS=$as_save_IFS
18725
18726 ;;
18727 esac
18728 fi
18729 HG=$ac_cv_path_HG
18730 if test -n "$HG"; then
18731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18732 $as_echo "$HG" >&6; }
18733 else
18734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18735 $as_echo "no" >&6; }
18736 fi
18737
18738
18739 if test "x$HG" = x; then
18740 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18741 fi
18742 else
18743 # Otherwise we believe it is a complete path. Use it as it is.
18744 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18745 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18747 $as_echo_n "checking for HG... " >&6; }
18748 if test ! -x "$tool_specified"; then
18749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18750 $as_echo "not found" >&6; }
18751 as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18752 fi
18753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18754 $as_echo "$tool_specified" >&6; }
18755 fi
18756 fi
18757 fi
18758
18759
18760
18761
18762 # Publish this variable in the help.
18763
18764
18765 if test "x$STAT" = x; then
18766 # The variable is not set by user, try to locate tool using the code snippet
18767 for ac_prog in stat
18768 do
18769 # Extract the first word of "$ac_prog", so it can be a program name with args.
18770 set dummy $ac_prog; ac_word=$2
18771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18772 $as_echo_n "checking for $ac_word... " >&6; }
18773 if ${ac_cv_path_STAT+:} false; then :
18774 $as_echo_n "(cached) " >&6
18775 else
18776 case $STAT in
18777 [\\/]* | ?:[\\/]*)
18778 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18779 ;;
18780 *)
18781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18782 for as_dir in $PATH
18783 do
18784 IFS=$as_save_IFS
18785 test -z "$as_dir" && as_dir=.
18786 for ac_exec_ext in '' $ac_executable_extensions; do
18787 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18788 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18789 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18790 break 2
18791 fi
18792 done
18793 done
18794 IFS=$as_save_IFS
18795
18796 ;;
18797 esac
18798 fi
18799 STAT=$ac_cv_path_STAT
18800 if test -n "$STAT"; then
18801 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18802 $as_echo "$STAT" >&6; }
18803 else
18804 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18805 $as_echo "no" >&6; }
18806 fi
18807
18808
18809 test -n "$STAT" && break
18810 done
18811
18812 else
18813 # The variable is set, but is it from the command line or the environment?
18814
18815 # Try to remove the string !STAT! from our list.
18816 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18817 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18818 # If it failed, the variable was not from the command line. Ignore it,
18819 # but warn the user (except for BASH, which is always set by the calling BASH).
18820 if test "xSTAT" != xBASH; then
18821 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18822 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18823 fi
18824 # Try to locate tool using the code snippet
18825 for ac_prog in stat
18826 do
18827 # Extract the first word of "$ac_prog", so it can be a program name with args.
18828 set dummy $ac_prog; ac_word=$2
18829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18830 $as_echo_n "checking for $ac_word... " >&6; }
18831 if ${ac_cv_path_STAT+:} false; then :
18832 $as_echo_n "(cached) " >&6
18833 else
18834 case $STAT in
18835 [\\/]* | ?:[\\/]*)
18836 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18837 ;;
18838 *)
18839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18840 for as_dir in $PATH
18841 do
18842 IFS=$as_save_IFS
18843 test -z "$as_dir" && as_dir=.
18844 for ac_exec_ext in '' $ac_executable_extensions; do
18845 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18846 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18847 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18848 break 2
18849 fi
18850 done
18851 done
18852 IFS=$as_save_IFS
18853
18854 ;;
18855 esac
18856 fi
18857 STAT=$ac_cv_path_STAT
18858 if test -n "$STAT"; then
18859 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18860 $as_echo "$STAT" >&6; }
18861 else
18862 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18863 $as_echo "no" >&6; }
18864 fi
18865
18866
18867 test -n "$STAT" && break
18868 done
18869
18870 else
18871 # If it succeeded, then it was overridden by the user. We will use it
18872 # for the tool.
18873
18874 # First remove it from the list of overridden variables, so we can test
18875 # for unknown variables in the end.
18876 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18877
18878 # Check if the provided tool contains a complete path.
18879 tool_specified="$STAT"
18880 tool_basename="${tool_specified##*/}"
18881 if test "x$tool_basename" = "x$tool_specified"; then
18882 # A command without a complete path is provided, search $PATH.
18883 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18884 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18885 # Extract the first word of "$tool_basename", so it can be a program name with args.
18886 set dummy $tool_basename; ac_word=$2
18887 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18888 $as_echo_n "checking for $ac_word... " >&6; }
18889 if ${ac_cv_path_STAT+:} false; then :
18890 $as_echo_n "(cached) " >&6
18891 else
18892 case $STAT in
18893 [\\/]* | ?:[\\/]*)
18894 ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18895 ;;
18896 *)
18897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18898 for as_dir in $PATH
18899 do
18900 IFS=$as_save_IFS
18901 test -z "$as_dir" && as_dir=.
18902 for ac_exec_ext in '' $ac_executable_extensions; do
18903 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18904 ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18905 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18906 break 2
18907 fi
18908 done
18909 done
18910 IFS=$as_save_IFS
18911
18912 ;;
18913 esac
18914 fi
18915 STAT=$ac_cv_path_STAT
18916 if test -n "$STAT"; then
18917 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18918 $as_echo "$STAT" >&6; }
18919 else
18920 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18921 $as_echo "no" >&6; }
18922 fi
18923
18924
18925 if test "x$STAT" = x; then
18926 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18927 fi
18928 else
18929 # Otherwise we believe it is a complete path. Use it as it is.
18930 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18931 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18932 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18933 $as_echo_n "checking for STAT... " >&6; }
18934 if test ! -x "$tool_specified"; then
18935 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18936 $as_echo "not found" >&6; }
18937 as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18938 fi
18939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18940 $as_echo "$tool_specified" >&6; }
18941 fi
18942 fi
18943 fi
18944
18945
18946
18947
18948 # Publish this variable in the help.
18949
18950
18951 if test "x$TIME" = x; then
18952 # The variable is not set by user, try to locate tool using the code snippet
18953 for ac_prog in time
18954 do
18955 # Extract the first word of "$ac_prog", so it can be a program name with args.
18956 set dummy $ac_prog; ac_word=$2
18957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18958 $as_echo_n "checking for $ac_word... " >&6; }
18959 if ${ac_cv_path_TIME+:} false; then :
18960 $as_echo_n "(cached) " >&6
18961 else
18962 case $TIME in
18963 [\\/]* | ?:[\\/]*)
18964 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18965 ;;
18966 *)
18967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18968 for as_dir in $PATH
18969 do
18970 IFS=$as_save_IFS
18971 test -z "$as_dir" && as_dir=.
18972 for ac_exec_ext in '' $ac_executable_extensions; do
18973 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18974 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18975 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18976 break 2
18977 fi
18978 done
18979 done
18980 IFS=$as_save_IFS
18981
18982 ;;
18983 esac
18984 fi
18985 TIME=$ac_cv_path_TIME
18986 if test -n "$TIME"; then
18987 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18988 $as_echo "$TIME" >&6; }
18989 else
18990 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18991 $as_echo "no" >&6; }
18992 fi
18993
18994
18995 test -n "$TIME" && break
18996 done
18997
18998 else
18999 # The variable is set, but is it from the command line or the environment?
19000
19001 # Try to remove the string !TIME! from our list.
19002 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
19003 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19004 # If it failed, the variable was not from the command line. Ignore it,
19005 # but warn the user (except for BASH, which is always set by the calling BASH).
19006 if test "xTIME" != xBASH; then
19007 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
19008 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
19009 fi
19010 # Try to locate tool using the code snippet
19011 for ac_prog in time
19012 do
19013 # Extract the first word of "$ac_prog", so it can be a program name with args.
19014 set dummy $ac_prog; ac_word=$2
19015 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19016 $as_echo_n "checking for $ac_word... " >&6; }
19017 if ${ac_cv_path_TIME+:} false; then :
19018 $as_echo_n "(cached) " >&6
19019 else
19020 case $TIME in
19021 [\\/]* | ?:[\\/]*)
19022 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
19023 ;;
19024 *)
19025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19026 for as_dir in $PATH
19027 do
19028 IFS=$as_save_IFS
19029 test -z "$as_dir" && as_dir=.
19030 for ac_exec_ext in '' $ac_executable_extensions; do
19031 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19032 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
19033 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19034 break 2
19035 fi
19036 done
19037 done
19038 IFS=$as_save_IFS
19039
19040 ;;
19041 esac
19042 fi
19043 TIME=$ac_cv_path_TIME
19044 if test -n "$TIME"; then
19045 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
19046 $as_echo "$TIME" >&6; }
19047 else
19048 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19049 $as_echo "no" >&6; }
19050 fi
19051
19052
19053 test -n "$TIME" && break
19054 done
19055
19056 else
19057 # If it succeeded, then it was overridden by the user. We will use it
19058 # for the tool.
19059
19060 # First remove it from the list of overridden variables, so we can test
19061 # for unknown variables in the end.
19062 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19063
19064 # Check if the provided tool contains a complete path.
19065 tool_specified="$TIME"
19066 tool_basename="${tool_specified##*/}"
19067 if test "x$tool_basename" = "x$tool_specified"; then
19068 # A command without a complete path is provided, search $PATH.
19069 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
19070 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
19071 # Extract the first word of "$tool_basename", so it can be a program name with args.
19072 set dummy $tool_basename; ac_word=$2
19073 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19074 $as_echo_n "checking for $ac_word... " >&6; }
19075 if ${ac_cv_path_TIME+:} false; then :
19076 $as_echo_n "(cached) " >&6
19077 else
19078 case $TIME in
19079 [\\/]* | ?:[\\/]*)
19080 ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
19081 ;;
19082 *)
19083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19084 for as_dir in $PATH
19085 do
19086 IFS=$as_save_IFS
19087 test -z "$as_dir" && as_dir=.
19088 for ac_exec_ext in '' $ac_executable_extensions; do
19089 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19090 ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
19091 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19092 break 2
19093 fi
19094 done
19095 done
19096 IFS=$as_save_IFS
19097
19098 ;;
19099 esac
19100 fi
19101 TIME=$ac_cv_path_TIME
19102 if test -n "$TIME"; then
19103 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
19104 $as_echo "$TIME" >&6; }
19105 else
19106 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19107 $as_echo "no" >&6; }
19108 fi
19109
19110
19111 if test "x$TIME" = x; then
19112 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19113 fi
19114 else
19115 # Otherwise we believe it is a complete path. Use it as it is.
19116 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
19117 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
19118 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
19119 $as_echo_n "checking for TIME... " >&6; }
19120 if test ! -x "$tool_specified"; then
19121 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19122 $as_echo "not found" >&6; }
19123 as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
19124 fi
19125 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19126 $as_echo "$tool_specified" >&6; }
19127 fi
19128 fi
19129 fi
19130
19131
19132 # Check if it's GNU time
19133 IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
19134 if test "x$IS_GNU_TIME" != x; then
19135 IS_GNU_TIME=yes
19136 else
19137 IS_GNU_TIME=no
19138 fi
19139
19140
19141 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
19142
19143
19144
19145 # Publish this variable in the help.
19146
19147
19148 if test "x$DSYMUTIL" = x; then
19149 # The variable is not set by user, try to locate tool using the code snippet
19150 for ac_prog in dsymutil
19151 do
19152 # Extract the first word of "$ac_prog", so it can be a program name with args.
19153 set dummy $ac_prog; ac_word=$2
19154 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19155 $as_echo_n "checking for $ac_word... " >&6; }
19156 if ${ac_cv_path_DSYMUTIL+:} false; then :
19157 $as_echo_n "(cached) " >&6
19158 else
19159 case $DSYMUTIL in
19160 [\\/]* | ?:[\\/]*)
19161 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19162 ;;
19163 *)
19164 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19165 for as_dir in $PATH
19166 do
19167 IFS=$as_save_IFS
19168 test -z "$as_dir" && as_dir=.
19169 for ac_exec_ext in '' $ac_executable_extensions; do
19170 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19171 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19172 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19173 break 2
19174 fi
19175 done
19176 done
19177 IFS=$as_save_IFS
19178
19179 ;;
19180 esac
19181 fi
19182 DSYMUTIL=$ac_cv_path_DSYMUTIL
19183 if test -n "$DSYMUTIL"; then
19184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19185 $as_echo "$DSYMUTIL" >&6; }
19186 else
19187 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19188 $as_echo "no" >&6; }
19189 fi
19190
19191
19192 test -n "$DSYMUTIL" && break
19193 done
19194
19195 else
19196 # The variable is set, but is it from the command line or the environment?
19197
19198 # Try to remove the string !DSYMUTIL! from our list.
19199 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
19200 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19201 # If it failed, the variable was not from the command line. Ignore it,
19202 # but warn the user (except for BASH, which is always set by the calling BASH).
19203 if test "xDSYMUTIL" != xBASH; then
19204 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
19205 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
19206 fi
19207 # Try to locate tool using the code snippet
19208 for ac_prog in dsymutil
19209 do
19210 # Extract the first word of "$ac_prog", so it can be a program name with args.
19211 set dummy $ac_prog; ac_word=$2
19212 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19213 $as_echo_n "checking for $ac_word... " >&6; }
19214 if ${ac_cv_path_DSYMUTIL+:} false; then :
19215 $as_echo_n "(cached) " >&6
19216 else
19217 case $DSYMUTIL in
19218 [\\/]* | ?:[\\/]*)
19219 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19220 ;;
19221 *)
19222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19223 for as_dir in $PATH
19224 do
19225 IFS=$as_save_IFS
19226 test -z "$as_dir" && as_dir=.
19227 for ac_exec_ext in '' $ac_executable_extensions; do
19228 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19229 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19230 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19231 break 2
19232 fi
19233 done
19234 done
19235 IFS=$as_save_IFS
19236
19237 ;;
19238 esac
19239 fi
19240 DSYMUTIL=$ac_cv_path_DSYMUTIL
19241 if test -n "$DSYMUTIL"; then
19242 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19243 $as_echo "$DSYMUTIL" >&6; }
19244 else
19245 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19246 $as_echo "no" >&6; }
19247 fi
19248
19249
19250 test -n "$DSYMUTIL" && break
19251 done
19252
19253 else
19254 # If it succeeded, then it was overridden by the user. We will use it
19255 # for the tool.
19256
19257 # First remove it from the list of overridden variables, so we can test
19258 # for unknown variables in the end.
19259 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19260
19261 # Check if the provided tool contains a complete path.
19262 tool_specified="$DSYMUTIL"
19263 tool_basename="${tool_specified##*/}"
19264 if test "x$tool_basename" = "x$tool_specified"; then
19265 # A command without a complete path is provided, search $PATH.
19266 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
19267 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
19268 # Extract the first word of "$tool_basename", so it can be a program name with args.
19269 set dummy $tool_basename; ac_word=$2
19270 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19271 $as_echo_n "checking for $ac_word... " >&6; }
19272 if ${ac_cv_path_DSYMUTIL+:} false; then :
19273 $as_echo_n "(cached) " >&6
19274 else
19275 case $DSYMUTIL in
19276 [\\/]* | ?:[\\/]*)
19277 ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19278 ;;
19279 *)
19280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19281 for as_dir in $PATH
19282 do
19283 IFS=$as_save_IFS
19284 test -z "$as_dir" && as_dir=.
19285 for ac_exec_ext in '' $ac_executable_extensions; do
19286 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19287 ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19288 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19289 break 2
19290 fi
19291 done
19292 done
19293 IFS=$as_save_IFS
19294
19295 ;;
19296 esac
19297 fi
19298 DSYMUTIL=$ac_cv_path_DSYMUTIL
19299 if test -n "$DSYMUTIL"; then
19300 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19301 $as_echo "$DSYMUTIL" >&6; }
19302 else
19303 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19304 $as_echo "no" >&6; }
19305 fi
19306
19307
19308 if test "x$DSYMUTIL" = x; then
19309 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19310 fi
19311 else
19312 # Otherwise we believe it is a complete path. Use it as it is.
19313 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
19314 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
19315 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
19316 $as_echo_n "checking for DSYMUTIL... " >&6; }
19317 if test ! -x "$tool_specified"; then
19318 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19319 $as_echo "not found" >&6; }
19320 as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
19321 fi
19322 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19323 $as_echo "$tool_specified" >&6; }
19324 fi
19325 fi
19326 fi
19327
19328
19329
19330 if test "x$DSYMUTIL" = x; then
19331 as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
19332 fi
19333
19334
19335
19336
19337
19338 # Publish this variable in the help.
19339
19340
19341 if test "x$XATTR" = x; then
19342 # The variable is not set by user, try to locate tool using the code snippet
19343 for ac_prog in xattr
19344 do
19345 # Extract the first word of "$ac_prog", so it can be a program name with args.
19346 set dummy $ac_prog; ac_word=$2
19347 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19348 $as_echo_n "checking for $ac_word... " >&6; }
19349 if ${ac_cv_path_XATTR+:} false; then :
19350 $as_echo_n "(cached) " >&6
19351 else
19352 case $XATTR in
19353 [\\/]* | ?:[\\/]*)
19354 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19355 ;;
19356 *)
19357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19358 for as_dir in $PATH
19359 do
19360 IFS=$as_save_IFS
19361 test -z "$as_dir" && as_dir=.
19362 for ac_exec_ext in '' $ac_executable_extensions; do
19363 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19364 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19365 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19366 break 2
19367 fi
19368 done
19369 done
19370 IFS=$as_save_IFS
19371
19372 ;;
19373 esac
19374 fi
19375 XATTR=$ac_cv_path_XATTR
19376 if test -n "$XATTR"; then
19377 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19378 $as_echo "$XATTR" >&6; }
19379 else
19380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19381 $as_echo "no" >&6; }
19382 fi
19383
19384
19385 test -n "$XATTR" && break
19386 done
19387
19388 else
19389 # The variable is set, but is it from the command line or the environment?
19390
19391 # Try to remove the string !XATTR! from our list.
19392 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19393 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19394 # If it failed, the variable was not from the command line. Ignore it,
19395 # but warn the user (except for BASH, which is always set by the calling BASH).
19396 if test "xXATTR" != xBASH; then
19397 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19398 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19399 fi
19400 # Try to locate tool using the code snippet
19401 for ac_prog in xattr
19402 do
19403 # Extract the first word of "$ac_prog", so it can be a program name with args.
19404 set dummy $ac_prog; ac_word=$2
19405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19406 $as_echo_n "checking for $ac_word... " >&6; }
19407 if ${ac_cv_path_XATTR+:} false; then :
19408 $as_echo_n "(cached) " >&6
19409 else
19410 case $XATTR in
19411 [\\/]* | ?:[\\/]*)
19412 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19413 ;;
19414 *)
19415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19416 for as_dir in $PATH
19417 do
19418 IFS=$as_save_IFS
19419 test -z "$as_dir" && as_dir=.
19420 for ac_exec_ext in '' $ac_executable_extensions; do
19421 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19422 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19423 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19424 break 2
19425 fi
19426 done
19427 done
19428 IFS=$as_save_IFS
19429
19430 ;;
19431 esac
19432 fi
19433 XATTR=$ac_cv_path_XATTR
19434 if test -n "$XATTR"; then
19435 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19436 $as_echo "$XATTR" >&6; }
19437 else
19438 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19439 $as_echo "no" >&6; }
19440 fi
19441
19442
19443 test -n "$XATTR" && break
19444 done
19445
19446 else
19447 # If it succeeded, then it was overridden by the user. We will use it
19448 # for the tool.
19449
19450 # First remove it from the list of overridden variables, so we can test
19451 # for unknown variables in the end.
19452 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19453
19454 # Check if the provided tool contains a complete path.
19455 tool_specified="$XATTR"
19456 tool_basename="${tool_specified##*/}"
19457 if test "x$tool_basename" = "x$tool_specified"; then
19458 # A command without a complete path is provided, search $PATH.
19459 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19460 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19461 # Extract the first word of "$tool_basename", so it can be a program name with args.
19462 set dummy $tool_basename; ac_word=$2
19463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19464 $as_echo_n "checking for $ac_word... " >&6; }
19465 if ${ac_cv_path_XATTR+:} false; then :
19466 $as_echo_n "(cached) " >&6
19467 else
19468 case $XATTR in
19469 [\\/]* | ?:[\\/]*)
19470 ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19471 ;;
19472 *)
19473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19474 for as_dir in $PATH
19475 do
19476 IFS=$as_save_IFS
19477 test -z "$as_dir" && as_dir=.
19478 for ac_exec_ext in '' $ac_executable_extensions; do
19479 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19480 ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19481 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19482 break 2
19483 fi
19484 done
19485 done
19486 IFS=$as_save_IFS
19487
19488 ;;
19489 esac
19490 fi
19491 XATTR=$ac_cv_path_XATTR
19492 if test -n "$XATTR"; then
19493 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19494 $as_echo "$XATTR" >&6; }
19495 else
19496 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19497 $as_echo "no" >&6; }
19498 fi
19499
19500
19501 if test "x$XATTR" = x; then
19502 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19503 fi
19504 else
19505 # Otherwise we believe it is a complete path. Use it as it is.
19506 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19507 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19509 $as_echo_n "checking for XATTR... " >&6; }
19510 if test ! -x "$tool_specified"; then
19511 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19512 $as_echo "not found" >&6; }
19513 as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19514 fi
19515 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19516 $as_echo "$tool_specified" >&6; }
19517 fi
19518 fi
19519 fi
19520
19521
19522
19523 if test "x$XATTR" = x; then
19524 as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19525 fi
19526
19527
19528
19529
19530 # Publish this variable in the help.
19531
19532
19533 if test "x$CODESIGN" = x; then
19534 # The variable is not set by user, try to locate tool using the code snippet
19535 for ac_prog in codesign
19536 do
19537 # Extract the first word of "$ac_prog", so it can be a program name with args.
19538 set dummy $ac_prog; ac_word=$2
19539 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19540 $as_echo_n "checking for $ac_word... " >&6; }
19541 if ${ac_cv_path_CODESIGN+:} false; then :
19542 $as_echo_n "(cached) " >&6
19543 else
19544 case $CODESIGN in
19545 [\\/]* | ?:[\\/]*)
19546 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19547 ;;
19548 *)
19549 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19550 for as_dir in $PATH
19551 do
19552 IFS=$as_save_IFS
19553 test -z "$as_dir" && as_dir=.
19554 for ac_exec_ext in '' $ac_executable_extensions; do
19555 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19556 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19557 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19558 break 2
19559 fi
19560 done
19561 done
19562 IFS=$as_save_IFS
19563
19564 ;;
19565 esac
19566 fi
19567 CODESIGN=$ac_cv_path_CODESIGN
19568 if test -n "$CODESIGN"; then
19569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19570 $as_echo "$CODESIGN" >&6; }
19571 else
19572 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19573 $as_echo "no" >&6; }
19574 fi
19575
19576
19577 test -n "$CODESIGN" && break
19578 done
19579
19580 else
19581 # The variable is set, but is it from the command line or the environment?
19582
19583 # Try to remove the string !CODESIGN! from our list.
19584 try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19585 if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19586 # If it failed, the variable was not from the command line. Ignore it,
19587 # but warn the user (except for BASH, which is always set by the calling BASH).
19588 if test "xCODESIGN" != xBASH; then
19589 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19590 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19591 fi
19592 # Try to locate tool using the code snippet
19593 for ac_prog in codesign
19594 do
19595 # Extract the first word of "$ac_prog", so it can be a program name with args.
19596 set dummy $ac_prog; ac_word=$2
19597 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19598 $as_echo_n "checking for $ac_word... " >&6; }
19599 if ${ac_cv_path_CODESIGN+:} false; then :
19600 $as_echo_n "(cached) " >&6
19601 else
19602 case $CODESIGN in
19603 [\\/]* | ?:[\\/]*)
19604 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19605 ;;
19606 *)
19607 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19608 for as_dir in $PATH
19609 do
19610 IFS=$as_save_IFS
19611 test -z "$as_dir" && as_dir=.
19612 for ac_exec_ext in '' $ac_executable_extensions; do
19613 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19614 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19615 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19616 break 2
19617 fi
19618 done
19619 done
19620 IFS=$as_save_IFS
19621
19622 ;;
19623 esac
19624 fi
19625 CODESIGN=$ac_cv_path_CODESIGN
19626 if test -n "$CODESIGN"; then
19627 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19628 $as_echo "$CODESIGN" >&6; }
19629 else
19630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19631 $as_echo "no" >&6; }
19632 fi
19633
19634
19635 test -n "$CODESIGN" && break
19636 done
19637
19638 else
19639 # If it succeeded, then it was overridden by the user. We will use it
19640 # for the tool.
19641
19642 # First remove it from the list of overridden variables, so we can test
19643 # for unknown variables in the end.
19644 CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19645
19646 # Check if the provided tool contains a complete path.
19647 tool_specified="$CODESIGN"
19648 tool_basename="${tool_specified##*/}"
19649 if test "x$tool_basename" = "x$tool_specified"; then
19650 # A command without a complete path is provided, search $PATH.
19651 { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19652 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19653 # Extract the first word of "$tool_basename", so it can be a program name with args.
19654 set dummy $tool_basename; ac_word=$2
19655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19656 $as_echo_n "checking for $ac_word... " >&6; }
19657 if ${ac_cv_path_CODESIGN+:} false; then :
19658 $as_echo_n "(cached) " >&6
19659 else
19660 case $CODESIGN in
19661 [\\/]* | ?:[\\/]*)
19662 ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19663 ;;
19664 *)
19665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19666 for as_dir in $PATH
19667 do
19668 IFS=$as_save_IFS
19669 test -z "$as_dir" && as_dir=.
19670 for ac_exec_ext in '' $ac_executable_extensions; do
19671 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19672 ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19673 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19674 break 2
19675 fi
19676 done
19677 done
19678 IFS=$as_save_IFS
19679
19680 ;;
19681 esac
19682 fi
19683 CODESIGN=$ac_cv_path_CODESIGN
19684 if test -n "$CODESIGN"; then
19685 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19686 $as_echo "$CODESIGN" >&6; }
19687 else
19688 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19689 $as_echo "no" >&6; }
19690 fi
19691
19692
19693 if test "x$CODESIGN" = x; then
19694 as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19695 fi
19696 else
19697 # Otherwise we believe it is a complete path. Use it as it is.
19698 { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19699 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19701 $as_echo_n "checking for CODESIGN... " >&6; }
19702 if test ! -x "$tool_specified"; then
19703 { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19704 $as_echo "not found" >&6; }
19705 as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19706 fi
19707 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19708 $as_echo "$tool_specified" >&6; }
19709 fi
19710 fi
19711 fi
19712
19713
19714 if test "x$CODESIGN" != "x"; then
19715 # Verify that the openjdk_codesign certificate is present
19716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19717 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19718 rm -f codesign-testfile
19719 touch codesign-testfile
19720 codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19721 rm -f codesign-testfile
19722 if test "x$CODESIGN" = x; then
19723 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19724 $as_echo "no" >&6; }
19725 else
19726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19727 $as_echo "yes" >&6; }
19728 fi
19729 fi
19730 fi
19731
19732
19733 # Test if bash supports pipefail.
19734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
19735 $as_echo_n "checking if bash supports pipefail... " >&6; }
19736 if ${BASH} -c 'set -o pipefail'; then
19737 BASH_ARGS="$BASH_ARGS -o pipefail"
19738 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19739 $as_echo "yes" >&6; }
19740 else
19741 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19742 $as_echo "no" >&6; }
19743 fi
19744
19745 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
19746 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
19747 if ${BASH} -e -c 'true'; then
19748 BASH_ARGS="$BASH_ARGS -e"
19749 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19750 $as_echo "yes" >&6; }
19751 else
19752 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19753 $as_echo "no" >&6; }
19754 fi
19755
19756
19757
19758
19759 # Check if pkg-config is available.
19760
19761
19762 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19763 if test -n "$ac_tool_prefix"; then
19764 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19765 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19766 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19767 $as_echo_n "checking for $ac_word... " >&6; }
19768 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19769 $as_echo_n "(cached) " >&6
19770 else
19771 case $PKG_CONFIG in
19772 [\\/]* | ?:[\\/]*)
19773 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19774 ;;
19775 *)
19776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19777 for as_dir in $PATH
19778 do
19779 IFS=$as_save_IFS
19780 test -z "$as_dir" && as_dir=.
19781 for ac_exec_ext in '' $ac_executable_extensions; do
19782 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19783 ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19784 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19785 break 2
19786 fi
19787 done
19788 done
19789 IFS=$as_save_IFS
19790
19791 ;;
19792 esac
19793 fi
19794 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19795 if test -n "$PKG_CONFIG"; then
19796 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19797 $as_echo "$PKG_CONFIG" >&6; }
19798 else
19799 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19800 $as_echo "no" >&6; }
19801 fi
19802
19803
19804 fi
19805 if test -z "$ac_cv_path_PKG_CONFIG"; then
19806 ac_pt_PKG_CONFIG=$PKG_CONFIG
19807 # Extract the first word of "pkg-config", so it can be a program name with args.
19808 set dummy pkg-config; ac_word=$2
19809 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19810 $as_echo_n "checking for $ac_word... " >&6; }
19811 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19812 $as_echo_n "(cached) " >&6
19813 else
19814 case $ac_pt_PKG_CONFIG in
19815 [\\/]* | ?:[\\/]*)
19816 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19817 ;;
19818 *)
19819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19820 for as_dir in $PATH
19821 do
19822 IFS=$as_save_IFS
19823 test -z "$as_dir" && as_dir=.
19824 for ac_exec_ext in '' $ac_executable_extensions; do
19825 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19826 ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19827 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19828 break 2
19829 fi
19830 done
19831 done
19832 IFS=$as_save_IFS
19833
19834 ;;
19835 esac
19836 fi
19837 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19838 if test -n "$ac_pt_PKG_CONFIG"; then
19839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19840 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19841 else
19842 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19843 $as_echo "no" >&6; }
19844 fi
19845
19846 if test "x$ac_pt_PKG_CONFIG" = x; then
19847 PKG_CONFIG=""
19848 else
19849 case $cross_compiling:$ac_tool_warned in
19850 yes:)
19851 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19852 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19853 ac_tool_warned=yes ;;
19854 esac
19855 PKG_CONFIG=$ac_pt_PKG_CONFIG
19856 fi
19857 else
19858 PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19859 fi
19860
19861 fi
19862 if test -n "$PKG_CONFIG"; then
19863 _pkg_min_version=0.9.0
19864 { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19865 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19866 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19868 $as_echo "yes" >&6; }
19869 else
19870 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19871 $as_echo "no" >&6; }
19872 PKG_CONFIG=""
19873 fi
19874
19875 fi
19876
19877 # After basic tools have been setup, we can check build os specific details.
19878
19879 ###############################################################################
19880
19881 # Note that this is the build platform OS version!
19882
19883 OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19884 OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19885 OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19886 OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19887
19888
19889
19890
19891
19892 # Setup builddeps, for automatic downloading of tools we need.
19893 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19894 # boot-jdk setup, but we need to have basic tools setup first.
19895
19896
19897 # Check whether --with-builddeps-conf was given.
19898 if test "${with_builddeps_conf+set}" = set; then :
19899 withval=$with_builddeps_conf;
19900 fi
19901
19902
19903
19904 # Check whether --with-builddeps-server was given.
19905 if test "${with_builddeps_server+set}" = set; then :
19906 withval=$with_builddeps_server;
19907 fi
19908
19909
19910
19911 # Check whether --with-builddeps-dir was given.
19912 if test "${with_builddeps_dir+set}" = set; then :
19913 withval=$with_builddeps_dir;
19914 else
19915 with_builddeps_dir=/localhome/builddeps
19916 fi
19917
19918
19919
19920 # Check whether --with-builddeps-group was given.
19921 if test "${with_builddeps_group+set}" = set; then :
19922 withval=$with_builddeps_group;
19923 fi
19924
19925
19926
19927
19928 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19929 if test "x$with_builddeps_conf" != x; then
19930 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19931 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19932 builddepsfile=$with_builddeps_conf
19933 if test -s $builddepsfile; then
19934 . $builddepsfile
19935 { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19936 $as_echo "loaded!" >&6; }
19937 else
19938 as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19939 fi
19940 else
19941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19942 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19943 builddepsfile=`mktemp`
19944 touch $builddepsfile
19945 # Put all found confs into a single file.
19946 find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19947 # Source the file to acquire the variables
19948 if test -s $builddepsfile; then
19949 . $builddepsfile
19950 { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19951 $as_echo "found at least one!" >&6; }
19952 else
19953 as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19954 fi
19955 fi
19956 # Create build and target names that use _ instead of "-" and ".".
19957 # This is necessary to use them in variable names.
19958 build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19959 target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19960 # Extract rewrite information for build and target
19961 eval rewritten_build=\${REWRITE_${build_var}}
19962 if test "x$rewritten_build" = x; then
19963 rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19964 echo Build stays the same $rewritten_build
19965 else
19966 echo Rewriting build for builddeps into $rewritten_build
19967 fi
19968 eval rewritten_target=\${REWRITE_${target_var}}
19969 if test "x$rewritten_target" = x; then
19970 rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19971 echo Target stays the same $rewritten_target
19972 else
19973 echo Rewriting target for builddeps into $rewritten_target
19974 fi
19975 rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19976 rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19977 fi
19978 for ac_prog in 7z unzip
19979 do
19980 # Extract the first word of "$ac_prog", so it can be a program name with args.
19981 set dummy $ac_prog; ac_word=$2
19982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19983 $as_echo_n "checking for $ac_word... " >&6; }
19984 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19985 $as_echo_n "(cached) " >&6
19986 else
19987 if test -n "$BDEPS_UNZIP"; then
19988 ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19989 else
19990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19991 for as_dir in $PATH
19992 do
19993 IFS=$as_save_IFS
19994 test -z "$as_dir" && as_dir=.
19995 for ac_exec_ext in '' $ac_executable_extensions; do
19996 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19997 ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19998 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19999 break 2
20000 fi
20001 done
20002 done
20003 IFS=$as_save_IFS
20004
20005 fi
20006 fi
20007 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
20008 if test -n "$BDEPS_UNZIP"; then
20009 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
20010 $as_echo "$BDEPS_UNZIP" >&6; }
20011 else
20012 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20013 $as_echo "no" >&6; }
20014 fi
20015
20016
20017 test -n "$BDEPS_UNZIP" && break
20018 done
20019
20020 if test "x$BDEPS_UNZIP" = x7z; then
20021 BDEPS_UNZIP="7z x"
20022 fi
20023
20024 for ac_prog in wget lftp ftp
20025 do
20026 # Extract the first word of "$ac_prog", so it can be a program name with args.
20027 set dummy $ac_prog; ac_word=$2
20028 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20029 $as_echo_n "checking for $ac_word... " >&6; }
20030 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
20031 $as_echo_n "(cached) " >&6
20032 else
20033 if test -n "$BDEPS_FTP"; then
20034 ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
20035 else
20036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20037 for as_dir in $PATH
20038 do
20039 IFS=$as_save_IFS
20040 test -z "$as_dir" && as_dir=.
20041 for ac_exec_ext in '' $ac_executable_extensions; do
20042 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20043 ac_cv_prog_BDEPS_FTP="$ac_prog"
20044 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20045 break 2
20046 fi
20047 done
20048 done
20049 IFS=$as_save_IFS
20050
20051 fi
20052 fi
20053 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
20054 if test -n "$BDEPS_FTP"; then
20055 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
20056 $as_echo "$BDEPS_FTP" >&6; }
20057 else
20058 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20059 $as_echo "no" >&6; }
20060 fi
20061
20062
20063 test -n "$BDEPS_FTP" && break
20064 done
20065
20066
20067
20068 ###############################################################################
20069 #
20070 # Determine OpenJDK variants, options and version numbers.
20071 #
20072 ###############################################################################
20073
20074 # We need build & target for this.
20075
20076
20077 ###############################################################################
20078 #
20079 # Should we build a JDK/JVM with headful support (ie a graphical ui)?
20080 # We always build headless support.
20081 #
20082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
20083 $as_echo_n "checking headful support... " >&6; }
20084 # Check whether --enable-headful was given.
20085 if test "${enable_headful+set}" = set; then :
20086 enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
20087 else
20088 SUPPORT_HEADFUL=yes
20089 fi
20090
20091
20092 SUPPORT_HEADLESS=yes
20093 BUILD_HEADLESS="BUILD_HEADLESS:=true"
20094
20095 if test "x$SUPPORT_HEADFUL" = xyes; then
20096 # We are building both headful and headless.
20097 headful_msg="include support for both headful and headless"
20098 fi
20099
20100 if test "x$SUPPORT_HEADFUL" = xno; then
20101 # Thus we are building headless only.
20102 BUILD_HEADLESS="BUILD_HEADLESS:=true"
20103 headful_msg="headless only"
20104 fi
20105
20106 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
20107 $as_echo "$headful_msg" >&6; }
20108
20109
20110
20111
20112
20113 # Control wether Hotspot runs Queens test after build.
20114 # Check whether --enable-hotspot-test-in-build was given.
20115 if test "${enable_hotspot_test_in_build+set}" = set; then :
20116 enableval=$enable_hotspot_test_in_build;
20117 else
20118 enable_hotspot_test_in_build=no
20119 fi
20120
20121 if test "x$enable_hotspot_test_in_build" = "xyes"; then
20122 TEST_IN_BUILD=true
20123 else
20124 TEST_IN_BUILD=false
20125 fi
20126
20127
20128 ###############################################################################
20129 #
20130 # Choose cacerts source file
20131 #
20132
20133 # Check whether --with-cacerts-file was given.
20134 if test "${with_cacerts_file+set}" = set; then :
20135 withval=$with_cacerts_file;
20136 fi
20137
20138 if test "x$with_cacerts_file" != x; then
20139 CACERTS_FILE=$with_cacerts_file
20140 fi
20141
20142
20143 ###############################################################################
20144 #
20145 # Enable or disable unlimited crypto
20146 #
20147 # Check whether --enable-unlimited-crypto was given.
20148 if test "${enable_unlimited_crypto+set}" = set; then :
20149 enableval=$enable_unlimited_crypto;
20150 else
20151 enable_unlimited_crypto=no
20152 fi
20153
20154 if test "x$enable_unlimited_crypto" = "xyes"; then
20155 UNLIMITED_CRYPTO=true
20156 else
20157 UNLIMITED_CRYPTO=false
20158 fi
20159
20160
20161 ###############################################################################
20162 #
20163 # --enable-rmiconnector-iiop
20164 #
20165 # Check whether --enable-rmiconnector-iiop was given.
20166 if test "${enable_rmiconnector_iiop+set}" = set; then :
20167 enableval=$enable_rmiconnector_iiop;
20168 fi
20169
20170 if test "x$enable_rmiconnector_iiop" = "xyes"; then
20171 RMICONNECTOR_IIOP=true
20172 else
20173 RMICONNECTOR_IIOP=false
20174 fi
20175
20176
20177 ###############################################################################
20178 #
20179 # Compress jars
20180 #
20181 COMPRESS_JARS=false
20182
20183
20184
20185 # Setup default copyright year. Mostly overridden when building close to a new year.
20186
20187 # Check whether --with-copyright-year was given.
20188 if test "${with_copyright_year+set}" = set; then :
20189 withval=$with_copyright_year;
20190 fi
20191
20192 if test "x$with_copyright_year" = xyes; then
20193 as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20194 elif test "x$with_copyright_year" != x; then
20195 COPYRIGHT_YEAR="$with_copyright_year"
20196 else
20197 COPYRIGHT_YEAR=`date +'%Y'`
20198 fi
20199
20200
20201
20202 # Warn user that old version arguments are deprecated.
20203
20204
20205 # Check whether --with-milestone was given.
20206 if test "${with_milestone+set}" = set; then :
20207 withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
20208 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
20209 fi
20210
20211
20212
20213
20214 # Check whether --with-update-version was given.
20215 if test "${with_update_version+set}" = set; then :
20216 withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
20217 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
20218 fi
20219
20220
20221
20222
20223 # Check whether --with-user-release-suffix was given.
20224 if test "${with_user_release_suffix+set}" = set; then :
20225 withval=$with_user_release_suffix; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&5
20226 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
20227 fi
20228
20229
20230
20231
20232 # Check whether --with-build-number was given.
20233 if test "${with_build_number+set}" = set; then :
20234 withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
20235 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
20236 fi
20237
20238
20239
20240 # Source the version numbers file
20241 . $AUTOCONF_DIR/version-numbers
20242
20243 # Some non-version number information is set in that file
20244
20245
20246
20247
20248
20249
20250
20251
20252 # Override version from arguments
20253
20254 # If --with-version-string is set, process it first. It is possible to
20255 # override parts with more specific flags, since these are processed later.
20256
20257 # Check whether --with-version-string was given.
20258 if test "${with_version_string+set}" = set; then :
20259 withval=$with_version_string;
20260 fi
20261
20262 if test "x$with_version_string" = xyes; then
20263 as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
20264 elif test "x$with_version_string" != x; then
20265 # Additional [] needed to keep m4 from mangling shell constructs.
20266 if [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?(\.([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
20267 VERSION_MAJOR=${BASH_REMATCH[1]}
20268 VERSION_MINOR=${BASH_REMATCH[3]}
20269 VERSION_SECURITY=${BASH_REMATCH[5]}
20270 VERSION_PATCH=${BASH_REMATCH[7]}
20271 VERSION_PRE_BASE=${BASH_REMATCH[9]}
20272 VERSION_PRE_DEBUGLEVEL=${BASH_REMATCH[11]}
20273 version_plus_separator=${BASH_REMATCH[13]}
20274 VERSION_BUILD=${BASH_REMATCH[14]}
20275 VERSION_OPT=${BASH_REMATCH[16]}
20276 # Unspecified numerical fields are interpreted as 0.
20277 if test "x$VERSION_MINOR" = x; then
20278 VERSION_MINOR=0
20279 fi
20280 if test "x$VERSION_SECURITY" = x; then
20281 VERSION_SECURITY=0
20282 fi
20283 if test "x$VERSION_PATCH" = x; then
20284 VERSION_PATCH=0
20285 fi
20286 if test "x$version_plus_separator" != x && test "x$VERSION_BUILD$VERSION_OPT" = x; then
20287 as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
20288 fi
20289 # Stop the version part process from setting default values.
20290 # We still allow them to explicitely override though.
20291 NO_DEFAULT_VERSION_PARTS=true
20292 else
20293 as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
20294 fi
20295 fi
20296
20297
20298 # Check whether --with-version-pre-base was given.
20299 if test "${with_version_pre_base+set}" = set; then :
20300 withval=$with_version_pre_base; with_version_pre_base_present=true
20301 else
20302 with_version_pre_base_present=false
20303 fi
20304
20305
20306 if test "x$with_version_pre_base_present" = xtrue; then
20307 if test "x$with_version_pre_base" = xyes; then
20308 as_fn_error $? "--with-version-pre-base must have a value" "$LINENO" 5
20309 elif test "x$with_version_pre_base" = xno; then
20310 # Interpret --without-* as empty string instead of the literal "no"
20311 VERSION_PRE_BASE=
20312 else
20313 # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
20314 VERSION_PRE_BASE=`$ECHO "$with_version_pre_base" | $TR -c -d '[a-z][A-Z]'`
20315 if test "x$VERSION_PRE_BASE" != "x$with_version_pre_base"; then
20316 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre-base value has been sanitized from '$with_version_pre_base' to '$VERSION_PRE_BASE'" >&5
20317 $as_echo "$as_me: WARNING: --with-version-pre-base value has been sanitized from '$with_version_pre_base' to '$VERSION_PRE_BASE'" >&2;}
20318 fi
20319 fi
20320 else
20321 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20322 # Default is to use "internal" as pre
20323 VERSION_PRE_BASE="internal"
20324 fi
20325 fi
20326
20327
20328 # Check whether --with-version-pre-debuglevel was given.
20329 if test "${with_version_pre_debuglevel+set}" = set; then :
20330 withval=$with_version_pre_debuglevel; with_version_pre_debuglevel_present=true
20331 else
20332 with_version_pre_debuglevel_present=false
20333 fi
20334
20335
20336 if test "x$with_version_pre_debuglevel_present" = xtrue; then
20337 if test "x$with_version_pre_debuglevel" = xyes; then
20338 as_fn_error $? "--with-version-pre-debuglevel must have a value" "$LINENO" 5
20339 elif test "x$with_version_pre_debuglevel" = xno; then
20340 # Interpret --without-* as empty string instead of the literal "no"
20341 VERSION_PRE_DEBUGLEVEL=
20342 else
20343 # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
20344 VERSION_PRE_DEBUGLEVEL=`$ECHO "$with_version_pre_debuglevel" | $TR -c -d '[a-z][A-Z]'`
20345 if test "x$VERSION_PRE_DEBUGLEVEL" != "x$with_version_pre_debuglevel"; then
20346 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre-debuglevel value has been sanitized from '$with_version_pre_debuglevel' to '$VERSION_PRE_DEBUGLEVEL'" >&5
20347 $as_echo "$as_me: WARNING: --with-version-pre-debuglevel value has been sanitized from '$with_version_pre_debuglevel' to '$VERSION_PRE_DEBUGLEVEL'" >&2;}
20348 fi
20349 fi
20350 else
20351 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20352 # Default is to use the debug level name, except for release which is empty.
20353 if test "x$DEBUG_LEVEL" != "xrelease"; then
20354 VERSION_PRE_DEBUGLEVEL="$DEBUG_LEVEL"
20355 else
20356 VERSION_PRE_DEBUGLEVEL=""
20357 fi
20358 fi
20359 fi
20360
20361
20362 # Check whether --with-version-opt was given.
20363 if test "${with_version_opt+set}" = set; then :
20364 withval=$with_version_opt; with_version_opt_present=true
20365 else
20366 with_version_opt_present=false
20367 fi
20368
20369
20370 if test "x$with_version_opt_present" = xtrue; then
20371 if test "x$with_version_opt" = xyes; then
20372 as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
20373 elif test "x$with_version_opt" = xno; then
20374 # Interpret --without-* as empty string instead of the literal "no"
20375 VERSION_OPT=
20376 else
20377 # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
20378 VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
20379 if test "x$VERSION_OPT" != "x$with_version_opt"; then
20380 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
20381 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
20382 fi
20383 fi
20384 else
20385 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20386 # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
20387 timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
20388 # Outer [ ] to quote m4.
20389 username=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
20390 basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
20391 VERSION_OPT="$timestamp.$username.$basedirname"
20392 fi
20393 fi
20394
20395
20396 # Check whether --with-version-build was given.
20397 if test "${with_version_build+set}" = set; then :
20398 withval=$with_version_build; with_version_build_present=true
20399 else
20400 with_version_build_present=false
20401 fi
20402
20403
20404 if test "x$with_version_build_present" = xtrue; then
20405 if test "x$with_version_build" = xyes; then
20406 as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
20407 elif test "x$with_version_build" = xno; then
20408 # Interpret --without-* as empty string instead of the literal "no"
20409 VERSION_BUILD=
20410 elif test "x$with_version_build" = x; then
20411 VERSION_BUILD=
20412 else
20413
20414 # Additional [] needed to keep m4 from mangling shell constructs.
20415 if ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
20416 as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
20417 fi
20418 # Extract the version number without leading zeros.
20419 cleaned_value=${BASH_REMATCH[1]}
20420 if test "x$cleaned_value" = x; then
20421 # Special case for zero
20422 cleaned_value=${BASH_REMATCH[2]}
20423 fi
20424
20425 if test $cleaned_value -gt 255; then
20426 as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
20427 fi
20428 if test "x$cleaned_value" != "x$with_version_build"; then
20429 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
20430 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
20431 fi
20432 VERSION_BUILD=$cleaned_value
20433
20434 fi
20435 else
20436 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20437 # Default is to not have a build number.
20438 VERSION_BUILD=""
20439 # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
20440 VERSION_BUILD=0
20441 fi
20442 fi
20443
20444
20445 # Check whether --with-version-major was given.
20446 if test "${with_version_major+set}" = set; then :
20447 withval=$with_version_major; with_version_major_present=true
20448 else
20449 with_version_major_present=false
20450 fi
20451
20452
20453 if test "x$with_version_major_present" = xtrue; then
20454 if test "x$with_version_major" = xyes; then
20455 as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
20456 else
20457
20458 # Additional [] needed to keep m4 from mangling shell constructs.
20459 if ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
20460 as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
20461 fi
20462 # Extract the version number without leading zeros.
20463 cleaned_value=${BASH_REMATCH[1]}
20464 if test "x$cleaned_value" = x; then
20465 # Special case for zero
20466 cleaned_value=${BASH_REMATCH[2]}
20467 fi
20468
20469 if test $cleaned_value -gt 255; then
20470 as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
20471 fi
20472 if test "x$cleaned_value" != "x$with_version_major"; then
20473 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
20474 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
20475 fi
20476 VERSION_MAJOR=$cleaned_value
20477
20478 fi
20479 else
20480 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20481 # Default is to get value from version-numbers
20482 VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
20483 fi
20484 fi
20485
20486
20487 # Check whether --with-version-minor was given.
20488 if test "${with_version_minor+set}" = set; then :
20489 withval=$with_version_minor; with_version_minor_present=true
20490 else
20491 with_version_minor_present=false
20492 fi
20493
20494
20495 if test "x$with_version_minor_present" = xtrue; then
20496 if test "x$with_version_minor" = xyes; then
20497 as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
20498 elif test "x$with_version_minor" = xno; then
20499 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
20500 VERSION_MINOR=0
20501 elif test "x$with_version_minor" = x; then
20502 VERSION_MINOR=0
20503 else
20504
20505 # Additional [] needed to keep m4 from mangling shell constructs.
20506 if ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
20507 as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
20508 fi
20509 # Extract the version number without leading zeros.
20510 cleaned_value=${BASH_REMATCH[1]}
20511 if test "x$cleaned_value" = x; then
20512 # Special case for zero
20513 cleaned_value=${BASH_REMATCH[2]}
20514 fi
20515
20516 if test $cleaned_value -gt 255; then
20517 as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
20518 fi
20519 if test "x$cleaned_value" != "x$with_version_minor"; then
20520 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
20521 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
20522 fi
20523 VERSION_MINOR=$cleaned_value
20524
20525 fi
20526 else
20527 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20528 # Default is 0, if unspecified
20529 VERSION_MINOR=0
20530 fi
20531 fi
20532
20533
20534 # Check whether --with-version-security was given.
20535 if test "${with_version_security+set}" = set; then :
20536 withval=$with_version_security; with_version_security_present=true
20537 else
20538 with_version_security_present=false
20539 fi
20540
20541
20542 if test "x$with_version_security_present" = xtrue; then
20543 if test "x$with_version_security" = xyes; then
20544 as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
20545 elif test "x$with_version_security" = xno; then
20546 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
20547 VERSION_SECURITY=0
20548 elif test "x$with_version_security" = x; then
20549 VERSION_SECURITY=0
20550 else
20551
20552 # Additional [] needed to keep m4 from mangling shell constructs.
20553 if ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
20554 as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
20555 fi
20556 # Extract the version number without leading zeros.
20557 cleaned_value=${BASH_REMATCH[1]}
20558 if test "x$cleaned_value" = x; then
20559 # Special case for zero
20560 cleaned_value=${BASH_REMATCH[2]}
20561 fi
20562
20563 if test $cleaned_value -gt 255; then
20564 as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
20565 fi
20566 if test "x$cleaned_value" != "x$with_version_security"; then
20567 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
20568 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
20569 fi
20570 VERSION_SECURITY=$cleaned_value
20571
20572 fi
20573 else
20574 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20575 # Default is 0, if unspecified
20576 VERSION_SECURITY=0
20577 fi
20578 fi
20579
20580
20581 # Check whether --with-version-patch was given.
20582 if test "${with_version_patch+set}" = set; then :
20583 withval=$with_version_patch; with_version_patch_present=true
20584 else
20585 with_version_patch_present=false
20586 fi
20587
20588
20589 if test "x$with_version_patch_present" = xtrue; then
20590 if test "x$with_version_patch" = xyes; then
20591 as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
20592 elif test "x$with_version_patch" = xno; then
20593 # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
20594 VERSION_PATCH=0
20595 elif test "x$with_version_patch" = x; then
20596 VERSION_PATCH=0
20597 else
20598
20599 # Additional [] needed to keep m4 from mangling shell constructs.
20600 if ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
20601 as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
20602 fi
20603 # Extract the version number without leading zeros.
20604 cleaned_value=${BASH_REMATCH[1]}
20605 if test "x$cleaned_value" = x; then
20606 # Special case for zero
20607 cleaned_value=${BASH_REMATCH[2]}
20608 fi
20609
20610 if test $cleaned_value -gt 255; then
20611 as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
20612 fi
20613 if test "x$cleaned_value" != "x$with_version_patch"; then
20614 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
20615 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
20616 fi
20617 VERSION_PATCH=$cleaned_value
20618
20619 fi
20620 else
20621 if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
20622 # Default is 0, if unspecified
20623 VERSION_PATCH=0
20624 fi
20625 fi
20626
20627 # Calculate derived version properties
20628
20629 # Set pre to "pre-base" if debug level is empty (i.e. release), or
20630 # "pre-base.debug-level" otherwise.
20631 if test "x$VERSION_PRE_BASE" = x && test "x$VERSION_PRE_DEBUGLEVEL" != x; then
20632 as_fn_error $? "Cannot set version-pre-debuglevel when version-pre-base is empty" "$LINENO" 5
20633 fi
20634 VERSION_PRE=$VERSION_PRE_BASE${VERSION_PRE_DEBUGLEVEL:+.$VERSION_PRE_DEBUGLEVEL}
20635
20636 # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
20637 VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
20638
20639 stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
20640 # Strip trailing zeroes from stripped_version_number
20641 for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
20642 VERSION_NUMBER=$stripped_version_number
20643
20644 # The complete version string, with additional build information
20645 if test "x$VERSION_BUILD$VERSION_OPT" = x; then
20646 VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
20647 else
20648 # If either build or opt is set, we need a + separator
20649 VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
20650 fi
20651
20652 # The short version string, just VERSION_NUMBER and PRE, if present.
20653 VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
20654
20655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
20656 $as_echo_n "checking for version string... " >&6; }
20657 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
20658 $as_echo "$VERSION_STRING" >&6; }
20659
20660
20661
20662
20663
20664
20665
20666
20667
20668
20669
20670
20671
20672
20673 ###############################################################################
20674 #
20675 # Setup BootJDK, used to bootstrap the build.
20676 #
20677 ###############################################################################
20678
20679
20680 BOOT_JDK_FOUND=no
20681
20682 # Check whether --with-boot-jdk was given.
20683 if test "${with_boot_jdk+set}" = set; then :
20684 withval=$with_boot_jdk;
20685 fi
20686
20687
20688 # We look for the Boot JDK through various means, going from more certain to
20689 # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20690 # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20691 # must check if this is indeed valid; otherwise we'll continue looking.
20692
20693 # Test: Is bootjdk explicitely set by command line arguments?
20694
20695 if test "x$BOOT_JDK_FOUND" = xno; then
20696 # Now execute the test
20697
20698 if test "x$with_boot_jdk" != x; then
20699 BOOT_JDK=$with_boot_jdk
20700 BOOT_JDK_FOUND=maybe
20701 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20702 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20703 fi
20704
20705
20706 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20707 if test "x$BOOT_JDK_FOUND" = xmaybe; then
20708 # Do we have a bin/java?
20709 if test ! -x "$BOOT_JDK/bin/java"; then
20710 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20711 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20712 BOOT_JDK_FOUND=no
20713 else
20714 # Do we have a bin/javac?
20715 if test ! -x "$BOOT_JDK/bin/javac"; then
20716 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20717 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20718 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20719 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20720 BOOT_JDK_FOUND=no
20721 else
20722 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20723 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20724
20725 # Extra M4 quote needed to protect [] in grep expression.
20726 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
20727 if test "x$FOUND_CORRECT_VERSION" = x; then
20728 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20729 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20730 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20731 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20732 BOOT_JDK_FOUND=no
20733 else
20734 # We're done! :-)
20735 BOOT_JDK_FOUND=yes
20736
20737 # Only process if variable expands to non-empty
20738
20739 if test "x$BOOT_JDK" != x; then
20740 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20741
20742 # Input might be given as Windows format, start by converting to
20743 # unix format.
20744 path="$BOOT_JDK"
20745 new_path=`$CYGPATH -u "$path"`
20746
20747 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20748 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20749 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20750 # "foo.exe" is OK but "foo" is an error.
20751 #
20752 # This test is therefore slightly more accurate than "test -f" to check for file precense.
20753 # It is also a way to make sure we got the proper file name for the real test later on.
20754 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20755 if test "x$test_shortpath" = x; then
20756 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20757 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20758 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20759 fi
20760
20761 # Call helper function which possibly converts this using DOS-style short mode.
20762 # If so, the updated path is stored in $new_path.
20763
20764 input_path="$new_path"
20765 # Check if we need to convert this using DOS-style short mode. If the path
20766 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20767 # take no chances and rewrite it.
20768 # Note: m4 eats our [], so we need to use [ and ] instead.
20769 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20770 if test "x$has_forbidden_chars" != x; then
20771 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20772 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20773 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20774 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20775 # Going to short mode and back again did indeed matter. Since short mode is
20776 # case insensitive, let's make it lowercase to improve readability.
20777 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20778 # Now convert it back to Unix-style (cygpath)
20779 input_path=`$CYGPATH -u "$shortmode_path"`
20780 new_path="$input_path"
20781 fi
20782 fi
20783
20784 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20785 if test "x$test_cygdrive_prefix" = x; then
20786 # As a simple fix, exclude /usr/bin since it's not a real path.
20787 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20788 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20789 # a path prefixed by /cygdrive for fixpath to work.
20790 new_path="$CYGWIN_ROOT_PATH$input_path"
20791 fi
20792 fi
20793
20794
20795 if test "x$path" != "x$new_path"; then
20796 BOOT_JDK="$new_path"
20797 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20798 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20799 fi
20800
20801 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20802
20803 path="$BOOT_JDK"
20804 has_colon=`$ECHO $path | $GREP ^.:`
20805 new_path="$path"
20806 if test "x$has_colon" = x; then
20807 # Not in mixed or Windows style, start by that.
20808 new_path=`cmd //c echo $path`
20809 fi
20810
20811
20812 input_path="$new_path"
20813 # Check if we need to convert this using DOS-style short mode. If the path
20814 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20815 # take no chances and rewrite it.
20816 # Note: m4 eats our [], so we need to use [ and ] instead.
20817 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20818 if test "x$has_forbidden_chars" != x; then
20819 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20820 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20821 fi
20822
20823
20824 windows_path="$new_path"
20825 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20826 unix_path=`$CYGPATH -u "$windows_path"`
20827 new_path="$unix_path"
20828 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20829 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20830 new_path="$unix_path"
20831 fi
20832
20833 if test "x$path" != "x$new_path"; then
20834 BOOT_JDK="$new_path"
20835 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20836 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20837 fi
20838
20839 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20840 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20841
20842 else
20843 # We're on a unix platform. Hooray! :)
20844 path="$BOOT_JDK"
20845 has_space=`$ECHO "$path" | $GREP " "`
20846 if test "x$has_space" != x; then
20847 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20848 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20849 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20850 fi
20851
20852 # Use eval to expand a potential ~
20853 eval path="$path"
20854 if test ! -f "$path" && test ! -d "$path"; then
20855 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20856 fi
20857
20858 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20859 fi
20860 fi
20861
20862 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20863 $as_echo_n "checking for Boot JDK... " >&6; }
20864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20865 $as_echo "$BOOT_JDK" >&6; }
20866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20867 $as_echo_n "checking Boot JDK version... " >&6; }
20868 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
20869 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20870 $as_echo "$BOOT_JDK_VERSION" >&6; }
20871 fi # end check jdk version
20872 fi # end check javac
20873 fi # end check java
20874 fi # end check boot jdk found
20875 fi
20876
20877 if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20878 # Having specified an argument which is incorrect will produce an instant failure;
20879 # we should not go on looking
20880 as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20881 fi
20882
20883 # Test: Is bootjdk available from builddeps?
20884
20885 if test "x$BOOT_JDK_FOUND" = xno; then
20886 # Now execute the test
20887
20888
20889
20890 if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20891 # Source the builddeps file again, to make sure it uses the latest variables!
20892 . $builddepsfile
20893 # Look for a target and build machine specific resource!
20894 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20895 if test "x$resource" = x; then
20896 # Ok, lets instead look for a target specific resource
20897 eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20898 fi
20899 if test "x$resource" = x; then
20900 # Ok, lets instead look for a build specific resource
20901 eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20902 fi
20903 if test "x$resource" = x; then
20904 # Ok, lets instead look for a generic resource
20905 # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20906 resource=${builddep_bootjdk}
20907 fi
20908 if test "x$resource" != x; then
20909 { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20910 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20911 # If the resource in the builddeps.conf file is an existing directory,
20912 # for example /java/linux/cups
20913 if test -d ${resource}; then
20914 depdir=${resource}
20915 else
20916
20917 # bootjdk is for example mymodule
20918 # $resource is for example libs/general/libmymod_1_2_3.zip
20919 # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20920 # $with_builddeps_dir is for example /localhome/builddeps
20921 # depdir is the name of the variable into which we store the depdir, eg MYMOD
20922 # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20923 # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20924 filename=`basename $resource`
20925 filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20926 filebase=${filename%%.*}
20927 extension=${filename#*.}
20928 installdir=$with_builddeps_dir/$filebase
20929 if test ! -f $installdir/$filename.unpacked; then
20930 { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20931 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20932 if test ! -d $installdir; then
20933 mkdir -p $installdir
20934 fi
20935 if test ! -d $installdir; then
20936 as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20937 fi
20938 tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20939 touch $tmpfile
20940 if test ! -f $tmpfile; then
20941 as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20942 fi
20943
20944 # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip
20945 # $tmpfile is the local file name for the downloaded file.
20946 VALID_TOOL=no
20947 if test "x$BDEPS_FTP" = xwget; then
20948 VALID_TOOL=yes
20949 wget -O $tmpfile $with_builddeps_server/$resource
20950 fi
20951 if test "x$BDEPS_FTP" = xlftp; then
20952 VALID_TOOL=yes
20953 lftp -c "get $with_builddeps_server/$resource -o $tmpfile"
20954 fi
20955 if test "x$BDEPS_FTP" = xftp; then
20956 VALID_TOOL=yes
20957 FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'`
20958 FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'`
20959 FTPUSERPWD=${FTPSERVER%%@*}
20960 if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20961 FTPUSER=${userpwd%%:*}
20962 FTPPWD=${userpwd#*@}
20963 FTPSERVER=${FTPSERVER#*@}
20964 else
20965 FTPUSER=ftp
20966 FTPPWD=ftp
20967 fi
20968 # the "pass" command does not work on some
20969 # ftp clients (read ftp.exe) but if it works,
20970 # passive mode is better!
20971 ( \
20972 echo "user $FTPUSER $FTPPWD" ; \
20973 echo "pass" ; \
20974 echo "bin" ; \
20975 echo "get $FTPPATH $tmpfile" ; \
20976 ) | ftp -in $FTPSERVER
20977 fi
20978 if test "x$VALID_TOOL" != xyes; then
20979 as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20980 fi
20981
20982 mv $tmpfile $installdir/$filename
20983 if test ! -s $installdir/$filename; then
20984 as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20985 fi
20986 case "$extension" in
20987 zip) echo "Unzipping $installdir/$filename..."
20988 (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20989 ;;
20990 tar.gz) echo "Untaring $installdir/$filename..."
20991 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20992 ;;
20993 tgz) echo "Untaring $installdir/$filename..."
20994 (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20995 ;;
20996 *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20997 ;;
20998 esac
20999 fi
21000 if test -f $installdir/$filename.unpacked; then
21001 depdir=$installdir
21002 fi
21003
21004 fi
21005 # Source the builddeps file again, because in the previous command, the depdir
21006 # was updated to point at the current build dependency install directory.
21007 . $builddepsfile
21008 # Now extract variables from the builddeps.conf files.
21009 theroot=${builddep_bootjdk_ROOT}
21010 thecflags=${builddep_bootjdk_CFLAGS}
21011 thelibs=${builddep_bootjdk_LIBS}
21012 if test "x$depdir" = x; then
21013 as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
21014 fi
21015 BOOT_JDK=$depdir
21016 if test "x$theroot" != x; then
21017 BOOT_JDK="$theroot"
21018 fi
21019 if test "x$thecflags" != x; then
21020 BOOT_JDK_CFLAGS="$thecflags"
21021 fi
21022 if test "x$thelibs" != x; then
21023 BOOT_JDK_LIBS="$thelibs"
21024 fi
21025 BOOT_JDK_FOUND=maybe
21026 else BOOT_JDK_FOUND=no
21027
21028 fi
21029 else BOOT_JDK_FOUND=no
21030
21031 fi
21032
21033
21034
21035 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21036 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21037 # Do we have a bin/java?
21038 if test ! -x "$BOOT_JDK/bin/java"; then
21039 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21040 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21041 BOOT_JDK_FOUND=no
21042 else
21043 # Do we have a bin/javac?
21044 if test ! -x "$BOOT_JDK/bin/javac"; then
21045 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21046 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21047 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21048 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21049 BOOT_JDK_FOUND=no
21050 else
21051 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21052 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21053
21054 # Extra M4 quote needed to protect [] in grep expression.
21055 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21056 if test "x$FOUND_CORRECT_VERSION" = x; then
21057 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21058 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21059 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21060 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21061 BOOT_JDK_FOUND=no
21062 else
21063 # We're done! :-)
21064 BOOT_JDK_FOUND=yes
21065
21066 # Only process if variable expands to non-empty
21067
21068 if test "x$BOOT_JDK" != x; then
21069 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21070
21071 # Input might be given as Windows format, start by converting to
21072 # unix format.
21073 path="$BOOT_JDK"
21074 new_path=`$CYGPATH -u "$path"`
21075
21076 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21077 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21078 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21079 # "foo.exe" is OK but "foo" is an error.
21080 #
21081 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21082 # It is also a way to make sure we got the proper file name for the real test later on.
21083 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21084 if test "x$test_shortpath" = x; then
21085 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21086 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21087 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21088 fi
21089
21090 # Call helper function which possibly converts this using DOS-style short mode.
21091 # If so, the updated path is stored in $new_path.
21092
21093 input_path="$new_path"
21094 # Check if we need to convert this using DOS-style short mode. If the path
21095 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21096 # take no chances and rewrite it.
21097 # Note: m4 eats our [], so we need to use [ and ] instead.
21098 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21099 if test "x$has_forbidden_chars" != x; then
21100 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21101 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21102 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21103 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21104 # Going to short mode and back again did indeed matter. Since short mode is
21105 # case insensitive, let's make it lowercase to improve readability.
21106 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21107 # Now convert it back to Unix-style (cygpath)
21108 input_path=`$CYGPATH -u "$shortmode_path"`
21109 new_path="$input_path"
21110 fi
21111 fi
21112
21113 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21114 if test "x$test_cygdrive_prefix" = x; then
21115 # As a simple fix, exclude /usr/bin since it's not a real path.
21116 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21117 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21118 # a path prefixed by /cygdrive for fixpath to work.
21119 new_path="$CYGWIN_ROOT_PATH$input_path"
21120 fi
21121 fi
21122
21123
21124 if test "x$path" != "x$new_path"; then
21125 BOOT_JDK="$new_path"
21126 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21127 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21128 fi
21129
21130 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21131
21132 path="$BOOT_JDK"
21133 has_colon=`$ECHO $path | $GREP ^.:`
21134 new_path="$path"
21135 if test "x$has_colon" = x; then
21136 # Not in mixed or Windows style, start by that.
21137 new_path=`cmd //c echo $path`
21138 fi
21139
21140
21141 input_path="$new_path"
21142 # Check if we need to convert this using DOS-style short mode. If the path
21143 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21144 # take no chances and rewrite it.
21145 # Note: m4 eats our [], so we need to use [ and ] instead.
21146 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21147 if test "x$has_forbidden_chars" != x; then
21148 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21149 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21150 fi
21151
21152
21153 windows_path="$new_path"
21154 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21155 unix_path=`$CYGPATH -u "$windows_path"`
21156 new_path="$unix_path"
21157 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21158 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21159 new_path="$unix_path"
21160 fi
21161
21162 if test "x$path" != "x$new_path"; then
21163 BOOT_JDK="$new_path"
21164 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21165 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21166 fi
21167
21168 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21169 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21170
21171 else
21172 # We're on a unix platform. Hooray! :)
21173 path="$BOOT_JDK"
21174 has_space=`$ECHO "$path" | $GREP " "`
21175 if test "x$has_space" != x; then
21176 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21177 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21178 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21179 fi
21180
21181 # Use eval to expand a potential ~
21182 eval path="$path"
21183 if test ! -f "$path" && test ! -d "$path"; then
21184 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21185 fi
21186
21187 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21188 fi
21189 fi
21190
21191 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21192 $as_echo_n "checking for Boot JDK... " >&6; }
21193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21194 $as_echo "$BOOT_JDK" >&6; }
21195 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21196 $as_echo_n "checking Boot JDK version... " >&6; }
21197 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21198 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21199 $as_echo "$BOOT_JDK_VERSION" >&6; }
21200 fi # end check jdk version
21201 fi # end check javac
21202 fi # end check java
21203 fi # end check boot jdk found
21204 fi
21205
21206
21207 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
21208
21209 if test "x$BOOT_JDK_FOUND" = xno; then
21210 # Now execute the test
21211
21212 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
21213 # First check at user selected default
21214
21215 if test "x$BOOT_JDK_FOUND" = xno; then
21216 # Now execute the test
21217
21218 if test -x /usr/libexec/java_home; then
21219 BOOT_JDK=`/usr/libexec/java_home `
21220 BOOT_JDK_FOUND=maybe
21221 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
21222 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
21223 fi
21224
21225
21226 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21227 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21228 # Do we have a bin/java?
21229 if test ! -x "$BOOT_JDK/bin/java"; then
21230 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21231 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21232 BOOT_JDK_FOUND=no
21233 else
21234 # Do we have a bin/javac?
21235 if test ! -x "$BOOT_JDK/bin/javac"; then
21236 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21237 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21238 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21239 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21240 BOOT_JDK_FOUND=no
21241 else
21242 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21243 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21244
21245 # Extra M4 quote needed to protect [] in grep expression.
21246 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21247 if test "x$FOUND_CORRECT_VERSION" = x; then
21248 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21249 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21250 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21251 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21252 BOOT_JDK_FOUND=no
21253 else
21254 # We're done! :-)
21255 BOOT_JDK_FOUND=yes
21256
21257 # Only process if variable expands to non-empty
21258
21259 if test "x$BOOT_JDK" != x; then
21260 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21261
21262 # Input might be given as Windows format, start by converting to
21263 # unix format.
21264 path="$BOOT_JDK"
21265 new_path=`$CYGPATH -u "$path"`
21266
21267 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21268 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21269 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21270 # "foo.exe" is OK but "foo" is an error.
21271 #
21272 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21273 # It is also a way to make sure we got the proper file name for the real test later on.
21274 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21275 if test "x$test_shortpath" = x; then
21276 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21277 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21278 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21279 fi
21280
21281 # Call helper function which possibly converts this using DOS-style short mode.
21282 # If so, the updated path is stored in $new_path.
21283
21284 input_path="$new_path"
21285 # Check if we need to convert this using DOS-style short mode. If the path
21286 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21287 # take no chances and rewrite it.
21288 # Note: m4 eats our [], so we need to use [ and ] instead.
21289 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21290 if test "x$has_forbidden_chars" != x; then
21291 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21292 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21293 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21294 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21295 # Going to short mode and back again did indeed matter. Since short mode is
21296 # case insensitive, let's make it lowercase to improve readability.
21297 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21298 # Now convert it back to Unix-style (cygpath)
21299 input_path=`$CYGPATH -u "$shortmode_path"`
21300 new_path="$input_path"
21301 fi
21302 fi
21303
21304 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21305 if test "x$test_cygdrive_prefix" = x; then
21306 # As a simple fix, exclude /usr/bin since it's not a real path.
21307 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21308 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21309 # a path prefixed by /cygdrive for fixpath to work.
21310 new_path="$CYGWIN_ROOT_PATH$input_path"
21311 fi
21312 fi
21313
21314
21315 if test "x$path" != "x$new_path"; then
21316 BOOT_JDK="$new_path"
21317 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21318 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21319 fi
21320
21321 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21322
21323 path="$BOOT_JDK"
21324 has_colon=`$ECHO $path | $GREP ^.:`
21325 new_path="$path"
21326 if test "x$has_colon" = x; then
21327 # Not in mixed or Windows style, start by that.
21328 new_path=`cmd //c echo $path`
21329 fi
21330
21331
21332 input_path="$new_path"
21333 # Check if we need to convert this using DOS-style short mode. If the path
21334 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21335 # take no chances and rewrite it.
21336 # Note: m4 eats our [], so we need to use [ and ] instead.
21337 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21338 if test "x$has_forbidden_chars" != x; then
21339 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21340 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21341 fi
21342
21343
21344 windows_path="$new_path"
21345 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21346 unix_path=`$CYGPATH -u "$windows_path"`
21347 new_path="$unix_path"
21348 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21349 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21350 new_path="$unix_path"
21351 fi
21352
21353 if test "x$path" != "x$new_path"; then
21354 BOOT_JDK="$new_path"
21355 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21356 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21357 fi
21358
21359 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21360 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21361
21362 else
21363 # We're on a unix platform. Hooray! :)
21364 path="$BOOT_JDK"
21365 has_space=`$ECHO "$path" | $GREP " "`
21366 if test "x$has_space" != x; then
21367 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21368 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21369 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21370 fi
21371
21372 # Use eval to expand a potential ~
21373 eval path="$path"
21374 if test ! -f "$path" && test ! -d "$path"; then
21375 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21376 fi
21377
21378 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21379 fi
21380 fi
21381
21382 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21383 $as_echo_n "checking for Boot JDK... " >&6; }
21384 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21385 $as_echo "$BOOT_JDK" >&6; }
21386 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21387 $as_echo_n "checking Boot JDK version... " >&6; }
21388 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21389 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21390 $as_echo "$BOOT_JDK_VERSION" >&6; }
21391 fi # end check jdk version
21392 fi # end check javac
21393 fi # end check java
21394 fi # end check boot jdk found
21395 fi
21396
21397 # If that did not work out (e.g. too old), try explicit versions instead
21398
21399 if test "x$BOOT_JDK_FOUND" = xno; then
21400 # Now execute the test
21401
21402 if test -x /usr/libexec/java_home; then
21403 BOOT_JDK=`/usr/libexec/java_home -v 1.9`
21404 BOOT_JDK_FOUND=maybe
21405 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
21406 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
21407 fi
21408
21409
21410 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21411 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21412 # Do we have a bin/java?
21413 if test ! -x "$BOOT_JDK/bin/java"; then
21414 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21415 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21416 BOOT_JDK_FOUND=no
21417 else
21418 # Do we have a bin/javac?
21419 if test ! -x "$BOOT_JDK/bin/javac"; then
21420 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21421 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21422 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21423 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21424 BOOT_JDK_FOUND=no
21425 else
21426 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21427 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21428
21429 # Extra M4 quote needed to protect [] in grep expression.
21430 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21431 if test "x$FOUND_CORRECT_VERSION" = x; then
21432 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21433 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21434 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21435 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21436 BOOT_JDK_FOUND=no
21437 else
21438 # We're done! :-)
21439 BOOT_JDK_FOUND=yes
21440
21441 # Only process if variable expands to non-empty
21442
21443 if test "x$BOOT_JDK" != x; then
21444 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21445
21446 # Input might be given as Windows format, start by converting to
21447 # unix format.
21448 path="$BOOT_JDK"
21449 new_path=`$CYGPATH -u "$path"`
21450
21451 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21452 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21453 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21454 # "foo.exe" is OK but "foo" is an error.
21455 #
21456 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21457 # It is also a way to make sure we got the proper file name for the real test later on.
21458 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21459 if test "x$test_shortpath" = x; then
21460 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21461 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21462 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21463 fi
21464
21465 # Call helper function which possibly converts this using DOS-style short mode.
21466 # If so, the updated path is stored in $new_path.
21467
21468 input_path="$new_path"
21469 # Check if we need to convert this using DOS-style short mode. If the path
21470 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21471 # take no chances and rewrite it.
21472 # Note: m4 eats our [], so we need to use [ and ] instead.
21473 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21474 if test "x$has_forbidden_chars" != x; then
21475 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21476 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21477 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21478 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21479 # Going to short mode and back again did indeed matter. Since short mode is
21480 # case insensitive, let's make it lowercase to improve readability.
21481 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21482 # Now convert it back to Unix-style (cygpath)
21483 input_path=`$CYGPATH -u "$shortmode_path"`
21484 new_path="$input_path"
21485 fi
21486 fi
21487
21488 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21489 if test "x$test_cygdrive_prefix" = x; then
21490 # As a simple fix, exclude /usr/bin since it's not a real path.
21491 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21492 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21493 # a path prefixed by /cygdrive for fixpath to work.
21494 new_path="$CYGWIN_ROOT_PATH$input_path"
21495 fi
21496 fi
21497
21498
21499 if test "x$path" != "x$new_path"; then
21500 BOOT_JDK="$new_path"
21501 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21502 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21503 fi
21504
21505 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21506
21507 path="$BOOT_JDK"
21508 has_colon=`$ECHO $path | $GREP ^.:`
21509 new_path="$path"
21510 if test "x$has_colon" = x; then
21511 # Not in mixed or Windows style, start by that.
21512 new_path=`cmd //c echo $path`
21513 fi
21514
21515
21516 input_path="$new_path"
21517 # Check if we need to convert this using DOS-style short mode. If the path
21518 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21519 # take no chances and rewrite it.
21520 # Note: m4 eats our [], so we need to use [ and ] instead.
21521 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21522 if test "x$has_forbidden_chars" != x; then
21523 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21524 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21525 fi
21526
21527
21528 windows_path="$new_path"
21529 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21530 unix_path=`$CYGPATH -u "$windows_path"`
21531 new_path="$unix_path"
21532 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21533 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21534 new_path="$unix_path"
21535 fi
21536
21537 if test "x$path" != "x$new_path"; then
21538 BOOT_JDK="$new_path"
21539 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21540 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21541 fi
21542
21543 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21544 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21545
21546 else
21547 # We're on a unix platform. Hooray! :)
21548 path="$BOOT_JDK"
21549 has_space=`$ECHO "$path" | $GREP " "`
21550 if test "x$has_space" != x; then
21551 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21552 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21553 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21554 fi
21555
21556 # Use eval to expand a potential ~
21557 eval path="$path"
21558 if test ! -f "$path" && test ! -d "$path"; then
21559 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21560 fi
21561
21562 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21563 fi
21564 fi
21565
21566 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21567 $as_echo_n "checking for Boot JDK... " >&6; }
21568 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21569 $as_echo "$BOOT_JDK" >&6; }
21570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21571 $as_echo_n "checking Boot JDK version... " >&6; }
21572 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21573 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21574 $as_echo "$BOOT_JDK_VERSION" >&6; }
21575 fi # end check jdk version
21576 fi # end check javac
21577 fi # end check java
21578 fi # end check boot jdk found
21579 fi
21580
21581
21582 if test "x$BOOT_JDK_FOUND" = xno; then
21583 # Now execute the test
21584
21585 if test -x /usr/libexec/java_home; then
21586 BOOT_JDK=`/usr/libexec/java_home -v 1.8`
21587 BOOT_JDK_FOUND=maybe
21588 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
21589 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
21590 fi
21591
21592
21593 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21594 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21595 # Do we have a bin/java?
21596 if test ! -x "$BOOT_JDK/bin/java"; then
21597 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21598 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21599 BOOT_JDK_FOUND=no
21600 else
21601 # Do we have a bin/javac?
21602 if test ! -x "$BOOT_JDK/bin/javac"; then
21603 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21604 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21605 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21606 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21607 BOOT_JDK_FOUND=no
21608 else
21609 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21610 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21611
21612 # Extra M4 quote needed to protect [] in grep expression.
21613 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21614 if test "x$FOUND_CORRECT_VERSION" = x; then
21615 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21616 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21617 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21618 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21619 BOOT_JDK_FOUND=no
21620 else
21621 # We're done! :-)
21622 BOOT_JDK_FOUND=yes
21623
21624 # Only process if variable expands to non-empty
21625
21626 if test "x$BOOT_JDK" != x; then
21627 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21628
21629 # Input might be given as Windows format, start by converting to
21630 # unix format.
21631 path="$BOOT_JDK"
21632 new_path=`$CYGPATH -u "$path"`
21633
21634 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21635 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21636 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21637 # "foo.exe" is OK but "foo" is an error.
21638 #
21639 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21640 # It is also a way to make sure we got the proper file name for the real test later on.
21641 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21642 if test "x$test_shortpath" = x; then
21643 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21644 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21645 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21646 fi
21647
21648 # Call helper function which possibly converts this using DOS-style short mode.
21649 # If so, the updated path is stored in $new_path.
21650
21651 input_path="$new_path"
21652 # Check if we need to convert this using DOS-style short mode. If the path
21653 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21654 # take no chances and rewrite it.
21655 # Note: m4 eats our [], so we need to use [ and ] instead.
21656 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21657 if test "x$has_forbidden_chars" != x; then
21658 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21659 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21660 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21661 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21662 # Going to short mode and back again did indeed matter. Since short mode is
21663 # case insensitive, let's make it lowercase to improve readability.
21664 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21665 # Now convert it back to Unix-style (cygpath)
21666 input_path=`$CYGPATH -u "$shortmode_path"`
21667 new_path="$input_path"
21668 fi
21669 fi
21670
21671 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21672 if test "x$test_cygdrive_prefix" = x; then
21673 # As a simple fix, exclude /usr/bin since it's not a real path.
21674 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21675 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21676 # a path prefixed by /cygdrive for fixpath to work.
21677 new_path="$CYGWIN_ROOT_PATH$input_path"
21678 fi
21679 fi
21680
21681
21682 if test "x$path" != "x$new_path"; then
21683 BOOT_JDK="$new_path"
21684 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21685 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21686 fi
21687
21688 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21689
21690 path="$BOOT_JDK"
21691 has_colon=`$ECHO $path | $GREP ^.:`
21692 new_path="$path"
21693 if test "x$has_colon" = x; then
21694 # Not in mixed or Windows style, start by that.
21695 new_path=`cmd //c echo $path`
21696 fi
21697
21698
21699 input_path="$new_path"
21700 # Check if we need to convert this using DOS-style short mode. If the path
21701 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21702 # take no chances and rewrite it.
21703 # Note: m4 eats our [], so we need to use [ and ] instead.
21704 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21705 if test "x$has_forbidden_chars" != x; then
21706 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21707 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21708 fi
21709
21710
21711 windows_path="$new_path"
21712 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21713 unix_path=`$CYGPATH -u "$windows_path"`
21714 new_path="$unix_path"
21715 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21716 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21717 new_path="$unix_path"
21718 fi
21719
21720 if test "x$path" != "x$new_path"; then
21721 BOOT_JDK="$new_path"
21722 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21723 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21724 fi
21725
21726 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21727 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21728
21729 else
21730 # We're on a unix platform. Hooray! :)
21731 path="$BOOT_JDK"
21732 has_space=`$ECHO "$path" | $GREP " "`
21733 if test "x$has_space" != x; then
21734 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21735 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21736 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21737 fi
21738
21739 # Use eval to expand a potential ~
21740 eval path="$path"
21741 if test ! -f "$path" && test ! -d "$path"; then
21742 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21743 fi
21744
21745 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21746 fi
21747 fi
21748
21749 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21750 $as_echo_n "checking for Boot JDK... " >&6; }
21751 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21752 $as_echo "$BOOT_JDK" >&6; }
21753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21754 $as_echo_n "checking Boot JDK version... " >&6; }
21755 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21756 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21757 $as_echo "$BOOT_JDK_VERSION" >&6; }
21758 fi # end check jdk version
21759 fi # end check javac
21760 fi # end check java
21761 fi # end check boot jdk found
21762 fi
21763
21764
21765 if test "x$BOOT_JDK_FOUND" = xno; then
21766 # Now execute the test
21767
21768 if test -x /usr/libexec/java_home; then
21769 BOOT_JDK=`/usr/libexec/java_home -v 1.7`
21770 BOOT_JDK_FOUND=maybe
21771 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
21772 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
21773 fi
21774
21775
21776 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21777 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21778 # Do we have a bin/java?
21779 if test ! -x "$BOOT_JDK/bin/java"; then
21780 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21781 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21782 BOOT_JDK_FOUND=no
21783 else
21784 # Do we have a bin/javac?
21785 if test ! -x "$BOOT_JDK/bin/javac"; then
21786 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21787 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21788 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21789 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21790 BOOT_JDK_FOUND=no
21791 else
21792 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21793 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21794
21795 # Extra M4 quote needed to protect [] in grep expression.
21796 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21797 if test "x$FOUND_CORRECT_VERSION" = x; then
21798 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21799 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21800 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21801 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21802 BOOT_JDK_FOUND=no
21803 else
21804 # We're done! :-)
21805 BOOT_JDK_FOUND=yes
21806
21807 # Only process if variable expands to non-empty
21808
21809 if test "x$BOOT_JDK" != x; then
21810 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21811
21812 # Input might be given as Windows format, start by converting to
21813 # unix format.
21814 path="$BOOT_JDK"
21815 new_path=`$CYGPATH -u "$path"`
21816
21817 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21818 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21819 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21820 # "foo.exe" is OK but "foo" is an error.
21821 #
21822 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21823 # It is also a way to make sure we got the proper file name for the real test later on.
21824 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21825 if test "x$test_shortpath" = x; then
21826 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21827 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21828 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21829 fi
21830
21831 # Call helper function which possibly converts this using DOS-style short mode.
21832 # If so, the updated path is stored in $new_path.
21833
21834 input_path="$new_path"
21835 # Check if we need to convert this using DOS-style short mode. If the path
21836 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21837 # take no chances and rewrite it.
21838 # Note: m4 eats our [], so we need to use [ and ] instead.
21839 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21840 if test "x$has_forbidden_chars" != x; then
21841 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21842 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21843 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21844 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21845 # Going to short mode and back again did indeed matter. Since short mode is
21846 # case insensitive, let's make it lowercase to improve readability.
21847 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21848 # Now convert it back to Unix-style (cygpath)
21849 input_path=`$CYGPATH -u "$shortmode_path"`
21850 new_path="$input_path"
21851 fi
21852 fi
21853
21854 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21855 if test "x$test_cygdrive_prefix" = x; then
21856 # As a simple fix, exclude /usr/bin since it's not a real path.
21857 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21858 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21859 # a path prefixed by /cygdrive for fixpath to work.
21860 new_path="$CYGWIN_ROOT_PATH$input_path"
21861 fi
21862 fi
21863
21864
21865 if test "x$path" != "x$new_path"; then
21866 BOOT_JDK="$new_path"
21867 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21868 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21869 fi
21870
21871 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21872
21873 path="$BOOT_JDK"
21874 has_colon=`$ECHO $path | $GREP ^.:`
21875 new_path="$path"
21876 if test "x$has_colon" = x; then
21877 # Not in mixed or Windows style, start by that.
21878 new_path=`cmd //c echo $path`
21879 fi
21880
21881
21882 input_path="$new_path"
21883 # Check if we need to convert this using DOS-style short mode. If the path
21884 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21885 # take no chances and rewrite it.
21886 # Note: m4 eats our [], so we need to use [ and ] instead.
21887 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21888 if test "x$has_forbidden_chars" != x; then
21889 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21890 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21891 fi
21892
21893
21894 windows_path="$new_path"
21895 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21896 unix_path=`$CYGPATH -u "$windows_path"`
21897 new_path="$unix_path"
21898 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21899 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21900 new_path="$unix_path"
21901 fi
21902
21903 if test "x$path" != "x$new_path"; then
21904 BOOT_JDK="$new_path"
21905 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21906 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21907 fi
21908
21909 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21910 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21911
21912 else
21913 # We're on a unix platform. Hooray! :)
21914 path="$BOOT_JDK"
21915 has_space=`$ECHO "$path" | $GREP " "`
21916 if test "x$has_space" != x; then
21917 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21918 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21919 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21920 fi
21921
21922 # Use eval to expand a potential ~
21923 eval path="$path"
21924 if test ! -f "$path" && test ! -d "$path"; then
21925 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21926 fi
21927
21928 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21929 fi
21930 fi
21931
21932 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21933 $as_echo_n "checking for Boot JDK... " >&6; }
21934 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21935 $as_echo "$BOOT_JDK" >&6; }
21936 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21937 $as_echo_n "checking Boot JDK version... " >&6; }
21938 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
21939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21940 $as_echo "$BOOT_JDK_VERSION" >&6; }
21941 fi # end check jdk version
21942 fi # end check javac
21943 fi # end check java
21944 fi # end check boot jdk found
21945 fi
21946
21947 fi
21948
21949
21950 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21951 if test "x$BOOT_JDK_FOUND" = xmaybe; then
21952 # Do we have a bin/java?
21953 if test ! -x "$BOOT_JDK/bin/java"; then
21954 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21955 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21956 BOOT_JDK_FOUND=no
21957 else
21958 # Do we have a bin/javac?
21959 if test ! -x "$BOOT_JDK/bin/javac"; then
21960 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21961 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21962 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21963 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21964 BOOT_JDK_FOUND=no
21965 else
21966 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21967 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21968
21969 # Extra M4 quote needed to protect [] in grep expression.
21970 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
21971 if test "x$FOUND_CORRECT_VERSION" = x; then
21972 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21973 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21974 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21975 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21976 BOOT_JDK_FOUND=no
21977 else
21978 # We're done! :-)
21979 BOOT_JDK_FOUND=yes
21980
21981 # Only process if variable expands to non-empty
21982
21983 if test "x$BOOT_JDK" != x; then
21984 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21985
21986 # Input might be given as Windows format, start by converting to
21987 # unix format.
21988 path="$BOOT_JDK"
21989 new_path=`$CYGPATH -u "$path"`
21990
21991 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21992 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21993 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21994 # "foo.exe" is OK but "foo" is an error.
21995 #
21996 # This test is therefore slightly more accurate than "test -f" to check for file precense.
21997 # It is also a way to make sure we got the proper file name for the real test later on.
21998 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21999 if test "x$test_shortpath" = x; then
22000 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22001 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22002 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22003 fi
22004
22005 # Call helper function which possibly converts this using DOS-style short mode.
22006 # If so, the updated path is stored in $new_path.
22007
22008 input_path="$new_path"
22009 # Check if we need to convert this using DOS-style short mode. If the path
22010 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22011 # take no chances and rewrite it.
22012 # Note: m4 eats our [], so we need to use [ and ] instead.
22013 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22014 if test "x$has_forbidden_chars" != x; then
22015 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22016 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22017 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22018 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22019 # Going to short mode and back again did indeed matter. Since short mode is
22020 # case insensitive, let's make it lowercase to improve readability.
22021 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22022 # Now convert it back to Unix-style (cygpath)
22023 input_path=`$CYGPATH -u "$shortmode_path"`
22024 new_path="$input_path"
22025 fi
22026 fi
22027
22028 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22029 if test "x$test_cygdrive_prefix" = x; then
22030 # As a simple fix, exclude /usr/bin since it's not a real path.
22031 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22032 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22033 # a path prefixed by /cygdrive for fixpath to work.
22034 new_path="$CYGWIN_ROOT_PATH$input_path"
22035 fi
22036 fi
22037
22038
22039 if test "x$path" != "x$new_path"; then
22040 BOOT_JDK="$new_path"
22041 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22042 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22043 fi
22044
22045 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22046
22047 path="$BOOT_JDK"
22048 has_colon=`$ECHO $path | $GREP ^.:`
22049 new_path="$path"
22050 if test "x$has_colon" = x; then
22051 # Not in mixed or Windows style, start by that.
22052 new_path=`cmd //c echo $path`
22053 fi
22054
22055
22056 input_path="$new_path"
22057 # Check if we need to convert this using DOS-style short mode. If the path
22058 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22059 # take no chances and rewrite it.
22060 # Note: m4 eats our [], so we need to use [ and ] instead.
22061 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22062 if test "x$has_forbidden_chars" != x; then
22063 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22064 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22065 fi
22066
22067
22068 windows_path="$new_path"
22069 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22070 unix_path=`$CYGPATH -u "$windows_path"`
22071 new_path="$unix_path"
22072 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22073 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22074 new_path="$unix_path"
22075 fi
22076
22077 if test "x$path" != "x$new_path"; then
22078 BOOT_JDK="$new_path"
22079 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22080 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22081 fi
22082
22083 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22084 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22085
22086 else
22087 # We're on a unix platform. Hooray! :)
22088 path="$BOOT_JDK"
22089 has_space=`$ECHO "$path" | $GREP " "`
22090 if test "x$has_space" != x; then
22091 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22092 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22093 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22094 fi
22095
22096 # Use eval to expand a potential ~
22097 eval path="$path"
22098 if test ! -f "$path" && test ! -d "$path"; then
22099 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22100 fi
22101
22102 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22103 fi
22104 fi
22105
22106 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22107 $as_echo_n "checking for Boot JDK... " >&6; }
22108 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22109 $as_echo "$BOOT_JDK" >&6; }
22110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22111 $as_echo_n "checking Boot JDK version... " >&6; }
22112 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22113 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22114 $as_echo "$BOOT_JDK_VERSION" >&6; }
22115 fi # end check jdk version
22116 fi # end check javac
22117 fi # end check java
22118 fi # end check boot jdk found
22119 fi
22120
22121
22122 # Test: Is $JAVA_HOME set?
22123
22124 if test "x$BOOT_JDK_FOUND" = xno; then
22125 # Now execute the test
22126
22127 if test "x$JAVA_HOME" != x; then
22128 JAVA_HOME_PROCESSED="$JAVA_HOME"
22129
22130 # Only process if variable expands to non-empty
22131
22132 if test "x$JAVA_HOME_PROCESSED" != x; then
22133 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22134
22135 # Input might be given as Windows format, start by converting to
22136 # unix format.
22137 path="$JAVA_HOME_PROCESSED"
22138 new_path=`$CYGPATH -u "$path"`
22139
22140 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22141 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22142 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22143 # "foo.exe" is OK but "foo" is an error.
22144 #
22145 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22146 # It is also a way to make sure we got the proper file name for the real test later on.
22147 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22148 if test "x$test_shortpath" = x; then
22149 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
22150 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
22151 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
22152 fi
22153
22154 # Call helper function which possibly converts this using DOS-style short mode.
22155 # If so, the updated path is stored in $new_path.
22156
22157 input_path="$new_path"
22158 # Check if we need to convert this using DOS-style short mode. If the path
22159 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22160 # take no chances and rewrite it.
22161 # Note: m4 eats our [], so we need to use [ and ] instead.
22162 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22163 if test "x$has_forbidden_chars" != x; then
22164 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22165 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22166 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22167 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22168 # Going to short mode and back again did indeed matter. Since short mode is
22169 # case insensitive, let's make it lowercase to improve readability.
22170 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22171 # Now convert it back to Unix-style (cygpath)
22172 input_path=`$CYGPATH -u "$shortmode_path"`
22173 new_path="$input_path"
22174 fi
22175 fi
22176
22177 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22178 if test "x$test_cygdrive_prefix" = x; then
22179 # As a simple fix, exclude /usr/bin since it's not a real path.
22180 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22181 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22182 # a path prefixed by /cygdrive for fixpath to work.
22183 new_path="$CYGWIN_ROOT_PATH$input_path"
22184 fi
22185 fi
22186
22187
22188 if test "x$path" != "x$new_path"; then
22189 JAVA_HOME_PROCESSED="$new_path"
22190 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
22191 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
22192 fi
22193
22194 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22195
22196 path="$JAVA_HOME_PROCESSED"
22197 has_colon=`$ECHO $path | $GREP ^.:`
22198 new_path="$path"
22199 if test "x$has_colon" = x; then
22200 # Not in mixed or Windows style, start by that.
22201 new_path=`cmd //c echo $path`
22202 fi
22203
22204
22205 input_path="$new_path"
22206 # Check if we need to convert this using DOS-style short mode. If the path
22207 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22208 # take no chances and rewrite it.
22209 # Note: m4 eats our [], so we need to use [ and ] instead.
22210 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22211 if test "x$has_forbidden_chars" != x; then
22212 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22213 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22214 fi
22215
22216
22217 windows_path="$new_path"
22218 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22219 unix_path=`$CYGPATH -u "$windows_path"`
22220 new_path="$unix_path"
22221 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22222 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22223 new_path="$unix_path"
22224 fi
22225
22226 if test "x$path" != "x$new_path"; then
22227 JAVA_HOME_PROCESSED="$new_path"
22228 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
22229 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
22230 fi
22231
22232 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22233 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22234
22235 else
22236 # We're on a unix platform. Hooray! :)
22237 path="$JAVA_HOME_PROCESSED"
22238 has_space=`$ECHO "$path" | $GREP " "`
22239 if test "x$has_space" != x; then
22240 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
22241 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
22242 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22243 fi
22244
22245 # Use eval to expand a potential ~
22246 eval path="$path"
22247 if test ! -f "$path" && test ! -d "$path"; then
22248 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
22249 fi
22250
22251 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
22252 fi
22253 fi
22254
22255 if test ! -d "$JAVA_HOME_PROCESSED"; then
22256 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
22257 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
22258 else
22259 # Aha, the user has set a JAVA_HOME
22260 # let us use that as the Boot JDK.
22261 BOOT_JDK="$JAVA_HOME_PROCESSED"
22262 BOOT_JDK_FOUND=maybe
22263 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
22264 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
22265 fi
22266 fi
22267
22268
22269 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22270 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22271 # Do we have a bin/java?
22272 if test ! -x "$BOOT_JDK/bin/java"; then
22273 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22274 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22275 BOOT_JDK_FOUND=no
22276 else
22277 # Do we have a bin/javac?
22278 if test ! -x "$BOOT_JDK/bin/javac"; then
22279 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22280 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22281 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22282 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22283 BOOT_JDK_FOUND=no
22284 else
22285 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22286 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22287
22288 # Extra M4 quote needed to protect [] in grep expression.
22289 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22290 if test "x$FOUND_CORRECT_VERSION" = x; then
22291 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22292 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22293 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22294 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22295 BOOT_JDK_FOUND=no
22296 else
22297 # We're done! :-)
22298 BOOT_JDK_FOUND=yes
22299
22300 # Only process if variable expands to non-empty
22301
22302 if test "x$BOOT_JDK" != x; then
22303 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22304
22305 # Input might be given as Windows format, start by converting to
22306 # unix format.
22307 path="$BOOT_JDK"
22308 new_path=`$CYGPATH -u "$path"`
22309
22310 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22311 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22312 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22313 # "foo.exe" is OK but "foo" is an error.
22314 #
22315 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22316 # It is also a way to make sure we got the proper file name for the real test later on.
22317 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22318 if test "x$test_shortpath" = x; then
22319 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22320 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22321 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22322 fi
22323
22324 # Call helper function which possibly converts this using DOS-style short mode.
22325 # If so, the updated path is stored in $new_path.
22326
22327 input_path="$new_path"
22328 # Check if we need to convert this using DOS-style short mode. If the path
22329 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22330 # take no chances and rewrite it.
22331 # Note: m4 eats our [], so we need to use [ and ] instead.
22332 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22333 if test "x$has_forbidden_chars" != x; then
22334 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22335 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22336 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22337 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22338 # Going to short mode and back again did indeed matter. Since short mode is
22339 # case insensitive, let's make it lowercase to improve readability.
22340 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22341 # Now convert it back to Unix-style (cygpath)
22342 input_path=`$CYGPATH -u "$shortmode_path"`
22343 new_path="$input_path"
22344 fi
22345 fi
22346
22347 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22348 if test "x$test_cygdrive_prefix" = x; then
22349 # As a simple fix, exclude /usr/bin since it's not a real path.
22350 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22351 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22352 # a path prefixed by /cygdrive for fixpath to work.
22353 new_path="$CYGWIN_ROOT_PATH$input_path"
22354 fi
22355 fi
22356
22357
22358 if test "x$path" != "x$new_path"; then
22359 BOOT_JDK="$new_path"
22360 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22361 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22362 fi
22363
22364 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22365
22366 path="$BOOT_JDK"
22367 has_colon=`$ECHO $path | $GREP ^.:`
22368 new_path="$path"
22369 if test "x$has_colon" = x; then
22370 # Not in mixed or Windows style, start by that.
22371 new_path=`cmd //c echo $path`
22372 fi
22373
22374
22375 input_path="$new_path"
22376 # Check if we need to convert this using DOS-style short mode. If the path
22377 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22378 # take no chances and rewrite it.
22379 # Note: m4 eats our [], so we need to use [ and ] instead.
22380 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22381 if test "x$has_forbidden_chars" != x; then
22382 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22383 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22384 fi
22385
22386
22387 windows_path="$new_path"
22388 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22389 unix_path=`$CYGPATH -u "$windows_path"`
22390 new_path="$unix_path"
22391 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22392 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22393 new_path="$unix_path"
22394 fi
22395
22396 if test "x$path" != "x$new_path"; then
22397 BOOT_JDK="$new_path"
22398 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22399 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22400 fi
22401
22402 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22403 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22404
22405 else
22406 # We're on a unix platform. Hooray! :)
22407 path="$BOOT_JDK"
22408 has_space=`$ECHO "$path" | $GREP " "`
22409 if test "x$has_space" != x; then
22410 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22411 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22412 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22413 fi
22414
22415 # Use eval to expand a potential ~
22416 eval path="$path"
22417 if test ! -f "$path" && test ! -d "$path"; then
22418 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22419 fi
22420
22421 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22422 fi
22423 fi
22424
22425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22426 $as_echo_n "checking for Boot JDK... " >&6; }
22427 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22428 $as_echo "$BOOT_JDK" >&6; }
22429 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22430 $as_echo_n "checking Boot JDK version... " >&6; }
22431 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22432 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22433 $as_echo "$BOOT_JDK_VERSION" >&6; }
22434 fi # end check jdk version
22435 fi # end check javac
22436 fi # end check java
22437 fi # end check boot jdk found
22438 fi
22439
22440
22441 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
22442
22443 if test "x$BOOT_JDK_FOUND" = xno; then
22444 # Now execute the test
22445
22446 # Extract the first word of "javac", so it can be a program name with args.
22447 set dummy javac; ac_word=$2
22448 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22449 $as_echo_n "checking for $ac_word... " >&6; }
22450 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
22451 $as_echo_n "(cached) " >&6
22452 else
22453 case $JAVAC_CHECK in
22454 [\\/]* | ?:[\\/]*)
22455 ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
22456 ;;
22457 *)
22458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22459 for as_dir in $PATH
22460 do
22461 IFS=$as_save_IFS
22462 test -z "$as_dir" && as_dir=.
22463 for ac_exec_ext in '' $ac_executable_extensions; do
22464 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22465 ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
22466 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22467 break 2
22468 fi
22469 done
22470 done
22471 IFS=$as_save_IFS
22472
22473 ;;
22474 esac
22475 fi
22476 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
22477 if test -n "$JAVAC_CHECK"; then
22478 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
22479 $as_echo "$JAVAC_CHECK" >&6; }
22480 else
22481 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22482 $as_echo "no" >&6; }
22483 fi
22484
22485
22486 # Extract the first word of "java", so it can be a program name with args.
22487 set dummy java; ac_word=$2
22488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22489 $as_echo_n "checking for $ac_word... " >&6; }
22490 if ${ac_cv_path_JAVA_CHECK+:} false; then :
22491 $as_echo_n "(cached) " >&6
22492 else
22493 case $JAVA_CHECK in
22494 [\\/]* | ?:[\\/]*)
22495 ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
22496 ;;
22497 *)
22498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22499 for as_dir in $PATH
22500 do
22501 IFS=$as_save_IFS
22502 test -z "$as_dir" && as_dir=.
22503 for ac_exec_ext in '' $ac_executable_extensions; do
22504 if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22505 ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
22506 $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22507 break 2
22508 fi
22509 done
22510 done
22511 IFS=$as_save_IFS
22512
22513 ;;
22514 esac
22515 fi
22516 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
22517 if test -n "$JAVA_CHECK"; then
22518 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
22519 $as_echo "$JAVA_CHECK" >&6; }
22520 else
22521 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22522 $as_echo "no" >&6; }
22523 fi
22524
22525
22526 BINARY="$JAVAC_CHECK"
22527 if test "x$JAVAC_CHECK" = x; then
22528 BINARY="$JAVA_CHECK"
22529 fi
22530 if test "x$BINARY" != x; then
22531 # So there is a java(c) binary, it might be part of a JDK.
22532 # Lets find the JDK/JRE directory by following symbolic links.
22533 # Linux/GNU systems often have links from /usr/bin/java to
22534 # /etc/alternatives/java to the real JDK binary.
22535
22536 if test "x$OPENJDK_BUILD_OS" != xwindows; then
22537 # Follow a chain of symbolic links. Use readlink
22538 # where it exists, else fall back to horribly
22539 # complicated shell code.
22540 if test "x$READLINK_TESTED" != yes; then
22541 # On MacOSX there is a readlink tool with a different
22542 # purpose than the GNU readlink tool. Check the found readlink.
22543 ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
22544 if test "x$ISGNU" = x; then
22545 # A readlink that we do not know how to use.
22546 # Are there other non-GNU readlinks out there?
22547 READLINK_TESTED=yes
22548 READLINK=
22549 fi
22550 fi
22551
22552 if test "x$READLINK" != x; then
22553 BINARY=`$READLINK -f $BINARY`
22554 else
22555 # Save the current directory for restoring afterwards
22556 STARTDIR=$PWD
22557 COUNTER=0
22558 sym_link_dir=`$DIRNAME $BINARY`
22559 sym_link_file=`$BASENAME $BINARY`
22560 cd $sym_link_dir
22561 # Use -P flag to resolve symlinks in directories.
22562 cd `$THEPWDCMD -P`
22563 sym_link_dir=`$THEPWDCMD -P`
22564 # Resolve file symlinks
22565 while test $COUNTER -lt 20; do
22566 ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
22567 if test "x$ISLINK" == x; then
22568 # This is not a symbolic link! We are done!
22569 break
22570 fi
22571 # Again resolve directory symlinks since the target of the just found
22572 # link could be in a different directory
22573 cd `$DIRNAME $ISLINK`
22574 sym_link_dir=`$THEPWDCMD -P`
22575 sym_link_file=`$BASENAME $ISLINK`
22576 let COUNTER=COUNTER+1
22577 done
22578 cd $STARTDIR
22579 BINARY=$sym_link_dir/$sym_link_file
22580 fi
22581 fi
22582
22583 BOOT_JDK=`dirname "$BINARY"`
22584 BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
22585 if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
22586 # Looks like we found ourselves an JDK
22587 BOOT_JDK_FOUND=maybe
22588 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
22589 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
22590 fi
22591 fi
22592
22593
22594 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22595 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22596 # Do we have a bin/java?
22597 if test ! -x "$BOOT_JDK/bin/java"; then
22598 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22599 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22600 BOOT_JDK_FOUND=no
22601 else
22602 # Do we have a bin/javac?
22603 if test ! -x "$BOOT_JDK/bin/javac"; then
22604 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22605 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22606 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22607 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22608 BOOT_JDK_FOUND=no
22609 else
22610 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22611 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22612
22613 # Extra M4 quote needed to protect [] in grep expression.
22614 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22615 if test "x$FOUND_CORRECT_VERSION" = x; then
22616 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22617 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22618 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22619 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22620 BOOT_JDK_FOUND=no
22621 else
22622 # We're done! :-)
22623 BOOT_JDK_FOUND=yes
22624
22625 # Only process if variable expands to non-empty
22626
22627 if test "x$BOOT_JDK" != x; then
22628 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22629
22630 # Input might be given as Windows format, start by converting to
22631 # unix format.
22632 path="$BOOT_JDK"
22633 new_path=`$CYGPATH -u "$path"`
22634
22635 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22636 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22637 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22638 # "foo.exe" is OK but "foo" is an error.
22639 #
22640 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22641 # It is also a way to make sure we got the proper file name for the real test later on.
22642 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22643 if test "x$test_shortpath" = x; then
22644 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22645 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22646 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22647 fi
22648
22649 # Call helper function which possibly converts this using DOS-style short mode.
22650 # If so, the updated path is stored in $new_path.
22651
22652 input_path="$new_path"
22653 # Check if we need to convert this using DOS-style short mode. If the path
22654 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22655 # take no chances and rewrite it.
22656 # Note: m4 eats our [], so we need to use [ and ] instead.
22657 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22658 if test "x$has_forbidden_chars" != x; then
22659 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22660 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22661 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22662 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22663 # Going to short mode and back again did indeed matter. Since short mode is
22664 # case insensitive, let's make it lowercase to improve readability.
22665 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22666 # Now convert it back to Unix-style (cygpath)
22667 input_path=`$CYGPATH -u "$shortmode_path"`
22668 new_path="$input_path"
22669 fi
22670 fi
22671
22672 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22673 if test "x$test_cygdrive_prefix" = x; then
22674 # As a simple fix, exclude /usr/bin since it's not a real path.
22675 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22676 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22677 # a path prefixed by /cygdrive for fixpath to work.
22678 new_path="$CYGWIN_ROOT_PATH$input_path"
22679 fi
22680 fi
22681
22682
22683 if test "x$path" != "x$new_path"; then
22684 BOOT_JDK="$new_path"
22685 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22686 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22687 fi
22688
22689 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22690
22691 path="$BOOT_JDK"
22692 has_colon=`$ECHO $path | $GREP ^.:`
22693 new_path="$path"
22694 if test "x$has_colon" = x; then
22695 # Not in mixed or Windows style, start by that.
22696 new_path=`cmd //c echo $path`
22697 fi
22698
22699
22700 input_path="$new_path"
22701 # Check if we need to convert this using DOS-style short mode. If the path
22702 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22703 # take no chances and rewrite it.
22704 # Note: m4 eats our [], so we need to use [ and ] instead.
22705 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22706 if test "x$has_forbidden_chars" != x; then
22707 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22708 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22709 fi
22710
22711
22712 windows_path="$new_path"
22713 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22714 unix_path=`$CYGPATH -u "$windows_path"`
22715 new_path="$unix_path"
22716 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22717 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22718 new_path="$unix_path"
22719 fi
22720
22721 if test "x$path" != "x$new_path"; then
22722 BOOT_JDK="$new_path"
22723 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22724 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22725 fi
22726
22727 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22728 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22729
22730 else
22731 # We're on a unix platform. Hooray! :)
22732 path="$BOOT_JDK"
22733 has_space=`$ECHO "$path" | $GREP " "`
22734 if test "x$has_space" != x; then
22735 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22736 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22737 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22738 fi
22739
22740 # Use eval to expand a potential ~
22741 eval path="$path"
22742 if test ! -f "$path" && test ! -d "$path"; then
22743 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22744 fi
22745
22746 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22747 fi
22748 fi
22749
22750 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22751 $as_echo_n "checking for Boot JDK... " >&6; }
22752 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22753 $as_echo "$BOOT_JDK" >&6; }
22754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22755 $as_echo_n "checking Boot JDK version... " >&6; }
22756 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22757 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22758 $as_echo "$BOOT_JDK_VERSION" >&6; }
22759 fi # end check jdk version
22760 fi # end check javac
22761 fi # end check java
22762 fi # end check boot jdk found
22763 fi
22764
22765
22766 # Test: Is there a JDK installed in default, well-known locations?
22767
22768 if test "x$BOOT_JDK_FOUND" = xno; then
22769 # Now execute the test
22770
22771 if test "x$OPENJDK_TARGET_OS" = xwindows; then
22772
22773 if test "x$BOOT_JDK_FOUND" = xno; then
22774 # Now execute the test
22775
22776 if test "x$ProgramW6432" != x; then
22777 VIRTUAL_DIR="$ProgramW6432/Java"
22778
22779 windows_path="$VIRTUAL_DIR"
22780 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22781 unix_path=`$CYGPATH -u "$windows_path"`
22782 VIRTUAL_DIR="$unix_path"
22783 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22784 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22785 VIRTUAL_DIR="$unix_path"
22786 fi
22787
22788
22789 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22790 BOOT_JDK_SUFFIX=""
22791 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22792 if test "x$ALL_JDKS_FOUND" != x; then
22793 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22794
22795 if test "x$BOOT_JDK_FOUND" = xno; then
22796 # Now execute the test
22797
22798 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22799 if test -d "$BOOT_JDK"; then
22800 BOOT_JDK_FOUND=maybe
22801 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22802 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22803 fi
22804
22805
22806 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22807 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22808 # Do we have a bin/java?
22809 if test ! -x "$BOOT_JDK/bin/java"; then
22810 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22811 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22812 BOOT_JDK_FOUND=no
22813 else
22814 # Do we have a bin/javac?
22815 if test ! -x "$BOOT_JDK/bin/javac"; then
22816 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22817 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22818 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22819 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22820 BOOT_JDK_FOUND=no
22821 else
22822 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22823 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22824
22825 # Extra M4 quote needed to protect [] in grep expression.
22826 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
22827 if test "x$FOUND_CORRECT_VERSION" = x; then
22828 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22829 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22830 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22831 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22832 BOOT_JDK_FOUND=no
22833 else
22834 # We're done! :-)
22835 BOOT_JDK_FOUND=yes
22836
22837 # Only process if variable expands to non-empty
22838
22839 if test "x$BOOT_JDK" != x; then
22840 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22841
22842 # Input might be given as Windows format, start by converting to
22843 # unix format.
22844 path="$BOOT_JDK"
22845 new_path=`$CYGPATH -u "$path"`
22846
22847 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22848 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22849 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22850 # "foo.exe" is OK but "foo" is an error.
22851 #
22852 # This test is therefore slightly more accurate than "test -f" to check for file precense.
22853 # It is also a way to make sure we got the proper file name for the real test later on.
22854 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22855 if test "x$test_shortpath" = x; then
22856 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22857 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22858 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22859 fi
22860
22861 # Call helper function which possibly converts this using DOS-style short mode.
22862 # If so, the updated path is stored in $new_path.
22863
22864 input_path="$new_path"
22865 # Check if we need to convert this using DOS-style short mode. If the path
22866 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22867 # take no chances and rewrite it.
22868 # Note: m4 eats our [], so we need to use [ and ] instead.
22869 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22870 if test "x$has_forbidden_chars" != x; then
22871 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22872 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22873 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22874 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22875 # Going to short mode and back again did indeed matter. Since short mode is
22876 # case insensitive, let's make it lowercase to improve readability.
22877 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22878 # Now convert it back to Unix-style (cygpath)
22879 input_path=`$CYGPATH -u "$shortmode_path"`
22880 new_path="$input_path"
22881 fi
22882 fi
22883
22884 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22885 if test "x$test_cygdrive_prefix" = x; then
22886 # As a simple fix, exclude /usr/bin since it's not a real path.
22887 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22888 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22889 # a path prefixed by /cygdrive for fixpath to work.
22890 new_path="$CYGWIN_ROOT_PATH$input_path"
22891 fi
22892 fi
22893
22894
22895 if test "x$path" != "x$new_path"; then
22896 BOOT_JDK="$new_path"
22897 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22898 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22899 fi
22900
22901 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22902
22903 path="$BOOT_JDK"
22904 has_colon=`$ECHO $path | $GREP ^.:`
22905 new_path="$path"
22906 if test "x$has_colon" = x; then
22907 # Not in mixed or Windows style, start by that.
22908 new_path=`cmd //c echo $path`
22909 fi
22910
22911
22912 input_path="$new_path"
22913 # Check if we need to convert this using DOS-style short mode. If the path
22914 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22915 # take no chances and rewrite it.
22916 # Note: m4 eats our [], so we need to use [ and ] instead.
22917 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22918 if test "x$has_forbidden_chars" != x; then
22919 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22920 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22921 fi
22922
22923
22924 windows_path="$new_path"
22925 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22926 unix_path=`$CYGPATH -u "$windows_path"`
22927 new_path="$unix_path"
22928 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22929 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22930 new_path="$unix_path"
22931 fi
22932
22933 if test "x$path" != "x$new_path"; then
22934 BOOT_JDK="$new_path"
22935 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22936 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22937 fi
22938
22939 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22940 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22941
22942 else
22943 # We're on a unix platform. Hooray! :)
22944 path="$BOOT_JDK"
22945 has_space=`$ECHO "$path" | $GREP " "`
22946 if test "x$has_space" != x; then
22947 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22948 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22949 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22950 fi
22951
22952 # Use eval to expand a potential ~
22953 eval path="$path"
22954 if test ! -f "$path" && test ! -d "$path"; then
22955 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22956 fi
22957
22958 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22959 fi
22960 fi
22961
22962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22963 $as_echo_n "checking for Boot JDK... " >&6; }
22964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22965 $as_echo "$BOOT_JDK" >&6; }
22966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22967 $as_echo_n "checking Boot JDK version... " >&6; }
22968 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
22969 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22970 $as_echo "$BOOT_JDK_VERSION" >&6; }
22971 fi # end check jdk version
22972 fi # end check javac
22973 fi # end check java
22974 fi # end check boot jdk found
22975 fi
22976
22977 done
22978 fi
22979
22980 fi
22981
22982
22983 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22984 if test "x$BOOT_JDK_FOUND" = xmaybe; then
22985 # Do we have a bin/java?
22986 if test ! -x "$BOOT_JDK/bin/java"; then
22987 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22988 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22989 BOOT_JDK_FOUND=no
22990 else
22991 # Do we have a bin/javac?
22992 if test ! -x "$BOOT_JDK/bin/javac"; then
22993 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22995 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22997 BOOT_JDK_FOUND=no
22998 else
22999 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23000 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23001
23002 # Extra M4 quote needed to protect [] in grep expression.
23003 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23004 if test "x$FOUND_CORRECT_VERSION" = x; then
23005 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23006 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23007 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23008 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23009 BOOT_JDK_FOUND=no
23010 else
23011 # We're done! :-)
23012 BOOT_JDK_FOUND=yes
23013
23014 # Only process if variable expands to non-empty
23015
23016 if test "x$BOOT_JDK" != x; then
23017 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23018
23019 # Input might be given as Windows format, start by converting to
23020 # unix format.
23021 path="$BOOT_JDK"
23022 new_path=`$CYGPATH -u "$path"`
23023
23024 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23025 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23026 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23027 # "foo.exe" is OK but "foo" is an error.
23028 #
23029 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23030 # It is also a way to make sure we got the proper file name for the real test later on.
23031 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23032 if test "x$test_shortpath" = x; then
23033 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23034 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23035 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23036 fi
23037
23038 # Call helper function which possibly converts this using DOS-style short mode.
23039 # If so, the updated path is stored in $new_path.
23040
23041 input_path="$new_path"
23042 # Check if we need to convert this using DOS-style short mode. If the path
23043 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23044 # take no chances and rewrite it.
23045 # Note: m4 eats our [], so we need to use [ and ] instead.
23046 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23047 if test "x$has_forbidden_chars" != x; then
23048 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23049 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23050 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23051 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23052 # Going to short mode and back again did indeed matter. Since short mode is
23053 # case insensitive, let's make it lowercase to improve readability.
23054 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23055 # Now convert it back to Unix-style (cygpath)
23056 input_path=`$CYGPATH -u "$shortmode_path"`
23057 new_path="$input_path"
23058 fi
23059 fi
23060
23061 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23062 if test "x$test_cygdrive_prefix" = x; then
23063 # As a simple fix, exclude /usr/bin since it's not a real path.
23064 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23065 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23066 # a path prefixed by /cygdrive for fixpath to work.
23067 new_path="$CYGWIN_ROOT_PATH$input_path"
23068 fi
23069 fi
23070
23071
23072 if test "x$path" != "x$new_path"; then
23073 BOOT_JDK="$new_path"
23074 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23075 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23076 fi
23077
23078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23079
23080 path="$BOOT_JDK"
23081 has_colon=`$ECHO $path | $GREP ^.:`
23082 new_path="$path"
23083 if test "x$has_colon" = x; then
23084 # Not in mixed or Windows style, start by that.
23085 new_path=`cmd //c echo $path`
23086 fi
23087
23088
23089 input_path="$new_path"
23090 # Check if we need to convert this using DOS-style short mode. If the path
23091 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23092 # take no chances and rewrite it.
23093 # Note: m4 eats our [], so we need to use [ and ] instead.
23094 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23095 if test "x$has_forbidden_chars" != x; then
23096 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23097 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23098 fi
23099
23100
23101 windows_path="$new_path"
23102 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23103 unix_path=`$CYGPATH -u "$windows_path"`
23104 new_path="$unix_path"
23105 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23106 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23107 new_path="$unix_path"
23108 fi
23109
23110 if test "x$path" != "x$new_path"; then
23111 BOOT_JDK="$new_path"
23112 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23113 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23114 fi
23115
23116 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23117 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23118
23119 else
23120 # We're on a unix platform. Hooray! :)
23121 path="$BOOT_JDK"
23122 has_space=`$ECHO "$path" | $GREP " "`
23123 if test "x$has_space" != x; then
23124 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23125 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23126 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23127 fi
23128
23129 # Use eval to expand a potential ~
23130 eval path="$path"
23131 if test ! -f "$path" && test ! -d "$path"; then
23132 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23133 fi
23134
23135 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23136 fi
23137 fi
23138
23139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23140 $as_echo_n "checking for Boot JDK... " >&6; }
23141 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23142 $as_echo "$BOOT_JDK" >&6; }
23143 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23144 $as_echo_n "checking Boot JDK version... " >&6; }
23145 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23146 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23147 $as_echo "$BOOT_JDK_VERSION" >&6; }
23148 fi # end check jdk version
23149 fi # end check javac
23150 fi # end check java
23151 fi # end check boot jdk found
23152 fi
23153
23154
23155 if test "x$BOOT_JDK_FOUND" = xno; then
23156 # Now execute the test
23157
23158 if test "x$PROGRAMW6432" != x; then
23159 VIRTUAL_DIR="$PROGRAMW6432/Java"
23160
23161 windows_path="$VIRTUAL_DIR"
23162 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23163 unix_path=`$CYGPATH -u "$windows_path"`
23164 VIRTUAL_DIR="$unix_path"
23165 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23166 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23167 VIRTUAL_DIR="$unix_path"
23168 fi
23169
23170
23171 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23172 BOOT_JDK_SUFFIX=""
23173 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23174 if test "x$ALL_JDKS_FOUND" != x; then
23175 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23176
23177 if test "x$BOOT_JDK_FOUND" = xno; then
23178 # Now execute the test
23179
23180 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23181 if test -d "$BOOT_JDK"; then
23182 BOOT_JDK_FOUND=maybe
23183 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23184 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23185 fi
23186
23187
23188 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23189 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23190 # Do we have a bin/java?
23191 if test ! -x "$BOOT_JDK/bin/java"; then
23192 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23193 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23194 BOOT_JDK_FOUND=no
23195 else
23196 # Do we have a bin/javac?
23197 if test ! -x "$BOOT_JDK/bin/javac"; then
23198 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23199 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23200 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23201 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23202 BOOT_JDK_FOUND=no
23203 else
23204 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23205 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23206
23207 # Extra M4 quote needed to protect [] in grep expression.
23208 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23209 if test "x$FOUND_CORRECT_VERSION" = x; then
23210 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23211 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23212 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23213 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23214 BOOT_JDK_FOUND=no
23215 else
23216 # We're done! :-)
23217 BOOT_JDK_FOUND=yes
23218
23219 # Only process if variable expands to non-empty
23220
23221 if test "x$BOOT_JDK" != x; then
23222 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23223
23224 # Input might be given as Windows format, start by converting to
23225 # unix format.
23226 path="$BOOT_JDK"
23227 new_path=`$CYGPATH -u "$path"`
23228
23229 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23230 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23231 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23232 # "foo.exe" is OK but "foo" is an error.
23233 #
23234 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23235 # It is also a way to make sure we got the proper file name for the real test later on.
23236 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23237 if test "x$test_shortpath" = x; then
23238 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23239 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23240 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23241 fi
23242
23243 # Call helper function which possibly converts this using DOS-style short mode.
23244 # If so, the updated path is stored in $new_path.
23245
23246 input_path="$new_path"
23247 # Check if we need to convert this using DOS-style short mode. If the path
23248 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23249 # take no chances and rewrite it.
23250 # Note: m4 eats our [], so we need to use [ and ] instead.
23251 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23252 if test "x$has_forbidden_chars" != x; then
23253 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23254 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23255 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23256 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23257 # Going to short mode and back again did indeed matter. Since short mode is
23258 # case insensitive, let's make it lowercase to improve readability.
23259 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23260 # Now convert it back to Unix-style (cygpath)
23261 input_path=`$CYGPATH -u "$shortmode_path"`
23262 new_path="$input_path"
23263 fi
23264 fi
23265
23266 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23267 if test "x$test_cygdrive_prefix" = x; then
23268 # As a simple fix, exclude /usr/bin since it's not a real path.
23269 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23270 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23271 # a path prefixed by /cygdrive for fixpath to work.
23272 new_path="$CYGWIN_ROOT_PATH$input_path"
23273 fi
23274 fi
23275
23276
23277 if test "x$path" != "x$new_path"; then
23278 BOOT_JDK="$new_path"
23279 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23280 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23281 fi
23282
23283 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23284
23285 path="$BOOT_JDK"
23286 has_colon=`$ECHO $path | $GREP ^.:`
23287 new_path="$path"
23288 if test "x$has_colon" = x; then
23289 # Not in mixed or Windows style, start by that.
23290 new_path=`cmd //c echo $path`
23291 fi
23292
23293
23294 input_path="$new_path"
23295 # Check if we need to convert this using DOS-style short mode. If the path
23296 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23297 # take no chances and rewrite it.
23298 # Note: m4 eats our [], so we need to use [ and ] instead.
23299 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23300 if test "x$has_forbidden_chars" != x; then
23301 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23302 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23303 fi
23304
23305
23306 windows_path="$new_path"
23307 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23308 unix_path=`$CYGPATH -u "$windows_path"`
23309 new_path="$unix_path"
23310 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23311 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23312 new_path="$unix_path"
23313 fi
23314
23315 if test "x$path" != "x$new_path"; then
23316 BOOT_JDK="$new_path"
23317 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23318 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23319 fi
23320
23321 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23322 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23323
23324 else
23325 # We're on a unix platform. Hooray! :)
23326 path="$BOOT_JDK"
23327 has_space=`$ECHO "$path" | $GREP " "`
23328 if test "x$has_space" != x; then
23329 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23330 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23331 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23332 fi
23333
23334 # Use eval to expand a potential ~
23335 eval path="$path"
23336 if test ! -f "$path" && test ! -d "$path"; then
23337 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23338 fi
23339
23340 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23341 fi
23342 fi
23343
23344 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23345 $as_echo_n "checking for Boot JDK... " >&6; }
23346 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23347 $as_echo "$BOOT_JDK" >&6; }
23348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23349 $as_echo_n "checking Boot JDK version... " >&6; }
23350 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23351 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23352 $as_echo "$BOOT_JDK_VERSION" >&6; }
23353 fi # end check jdk version
23354 fi # end check javac
23355 fi # end check java
23356 fi # end check boot jdk found
23357 fi
23358
23359 done
23360 fi
23361
23362 fi
23363
23364
23365 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23366 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23367 # Do we have a bin/java?
23368 if test ! -x "$BOOT_JDK/bin/java"; then
23369 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23370 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23371 BOOT_JDK_FOUND=no
23372 else
23373 # Do we have a bin/javac?
23374 if test ! -x "$BOOT_JDK/bin/javac"; then
23375 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23376 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23377 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23378 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23379 BOOT_JDK_FOUND=no
23380 else
23381 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23382 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23383
23384 # Extra M4 quote needed to protect [] in grep expression.
23385 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23386 if test "x$FOUND_CORRECT_VERSION" = x; then
23387 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23388 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23389 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23390 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23391 BOOT_JDK_FOUND=no
23392 else
23393 # We're done! :-)
23394 BOOT_JDK_FOUND=yes
23395
23396 # Only process if variable expands to non-empty
23397
23398 if test "x$BOOT_JDK" != x; then
23399 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23400
23401 # Input might be given as Windows format, start by converting to
23402 # unix format.
23403 path="$BOOT_JDK"
23404 new_path=`$CYGPATH -u "$path"`
23405
23406 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23407 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23408 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23409 # "foo.exe" is OK but "foo" is an error.
23410 #
23411 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23412 # It is also a way to make sure we got the proper file name for the real test later on.
23413 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23414 if test "x$test_shortpath" = x; then
23415 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23416 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23417 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23418 fi
23419
23420 # Call helper function which possibly converts this using DOS-style short mode.
23421 # If so, the updated path is stored in $new_path.
23422
23423 input_path="$new_path"
23424 # Check if we need to convert this using DOS-style short mode. If the path
23425 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23426 # take no chances and rewrite it.
23427 # Note: m4 eats our [], so we need to use [ and ] instead.
23428 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23429 if test "x$has_forbidden_chars" != x; then
23430 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23431 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23432 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23433 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23434 # Going to short mode and back again did indeed matter. Since short mode is
23435 # case insensitive, let's make it lowercase to improve readability.
23436 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23437 # Now convert it back to Unix-style (cygpath)
23438 input_path=`$CYGPATH -u "$shortmode_path"`
23439 new_path="$input_path"
23440 fi
23441 fi
23442
23443 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23444 if test "x$test_cygdrive_prefix" = x; then
23445 # As a simple fix, exclude /usr/bin since it's not a real path.
23446 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23447 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23448 # a path prefixed by /cygdrive for fixpath to work.
23449 new_path="$CYGWIN_ROOT_PATH$input_path"
23450 fi
23451 fi
23452
23453
23454 if test "x$path" != "x$new_path"; then
23455 BOOT_JDK="$new_path"
23456 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23457 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23458 fi
23459
23460 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23461
23462 path="$BOOT_JDK"
23463 has_colon=`$ECHO $path | $GREP ^.:`
23464 new_path="$path"
23465 if test "x$has_colon" = x; then
23466 # Not in mixed or Windows style, start by that.
23467 new_path=`cmd //c echo $path`
23468 fi
23469
23470
23471 input_path="$new_path"
23472 # Check if we need to convert this using DOS-style short mode. If the path
23473 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23474 # take no chances and rewrite it.
23475 # Note: m4 eats our [], so we need to use [ and ] instead.
23476 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23477 if test "x$has_forbidden_chars" != x; then
23478 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23479 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23480 fi
23481
23482
23483 windows_path="$new_path"
23484 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23485 unix_path=`$CYGPATH -u "$windows_path"`
23486 new_path="$unix_path"
23487 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23488 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23489 new_path="$unix_path"
23490 fi
23491
23492 if test "x$path" != "x$new_path"; then
23493 BOOT_JDK="$new_path"
23494 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23495 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23496 fi
23497
23498 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23499 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23500
23501 else
23502 # We're on a unix platform. Hooray! :)
23503 path="$BOOT_JDK"
23504 has_space=`$ECHO "$path" | $GREP " "`
23505 if test "x$has_space" != x; then
23506 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23507 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23508 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23509 fi
23510
23511 # Use eval to expand a potential ~
23512 eval path="$path"
23513 if test ! -f "$path" && test ! -d "$path"; then
23514 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23515 fi
23516
23517 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23518 fi
23519 fi
23520
23521 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23522 $as_echo_n "checking for Boot JDK... " >&6; }
23523 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23524 $as_echo "$BOOT_JDK" >&6; }
23525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23526 $as_echo_n "checking Boot JDK version... " >&6; }
23527 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23528 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23529 $as_echo "$BOOT_JDK_VERSION" >&6; }
23530 fi # end check jdk version
23531 fi # end check javac
23532 fi # end check java
23533 fi # end check boot jdk found
23534 fi
23535
23536
23537 if test "x$BOOT_JDK_FOUND" = xno; then
23538 # Now execute the test
23539
23540 if test "x$PROGRAMFILES" != x; then
23541 VIRTUAL_DIR="$PROGRAMFILES/Java"
23542
23543 windows_path="$VIRTUAL_DIR"
23544 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23545 unix_path=`$CYGPATH -u "$windows_path"`
23546 VIRTUAL_DIR="$unix_path"
23547 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23548 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23549 VIRTUAL_DIR="$unix_path"
23550 fi
23551
23552
23553 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23554 BOOT_JDK_SUFFIX=""
23555 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23556 if test "x$ALL_JDKS_FOUND" != x; then
23557 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23558
23559 if test "x$BOOT_JDK_FOUND" = xno; then
23560 # Now execute the test
23561
23562 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23563 if test -d "$BOOT_JDK"; then
23564 BOOT_JDK_FOUND=maybe
23565 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23566 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23567 fi
23568
23569
23570 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23571 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23572 # Do we have a bin/java?
23573 if test ! -x "$BOOT_JDK/bin/java"; then
23574 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23575 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23576 BOOT_JDK_FOUND=no
23577 else
23578 # Do we have a bin/javac?
23579 if test ! -x "$BOOT_JDK/bin/javac"; then
23580 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23581 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23582 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23583 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23584 BOOT_JDK_FOUND=no
23585 else
23586 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23587 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23588
23589 # Extra M4 quote needed to protect [] in grep expression.
23590 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23591 if test "x$FOUND_CORRECT_VERSION" = x; then
23592 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23593 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23594 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23595 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23596 BOOT_JDK_FOUND=no
23597 else
23598 # We're done! :-)
23599 BOOT_JDK_FOUND=yes
23600
23601 # Only process if variable expands to non-empty
23602
23603 if test "x$BOOT_JDK" != x; then
23604 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23605
23606 # Input might be given as Windows format, start by converting to
23607 # unix format.
23608 path="$BOOT_JDK"
23609 new_path=`$CYGPATH -u "$path"`
23610
23611 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23612 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23613 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23614 # "foo.exe" is OK but "foo" is an error.
23615 #
23616 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23617 # It is also a way to make sure we got the proper file name for the real test later on.
23618 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23619 if test "x$test_shortpath" = x; then
23620 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23621 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23622 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23623 fi
23624
23625 # Call helper function which possibly converts this using DOS-style short mode.
23626 # If so, the updated path is stored in $new_path.
23627
23628 input_path="$new_path"
23629 # Check if we need to convert this using DOS-style short mode. If the path
23630 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23631 # take no chances and rewrite it.
23632 # Note: m4 eats our [], so we need to use [ and ] instead.
23633 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23634 if test "x$has_forbidden_chars" != x; then
23635 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23636 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23637 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23638 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23639 # Going to short mode and back again did indeed matter. Since short mode is
23640 # case insensitive, let's make it lowercase to improve readability.
23641 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23642 # Now convert it back to Unix-style (cygpath)
23643 input_path=`$CYGPATH -u "$shortmode_path"`
23644 new_path="$input_path"
23645 fi
23646 fi
23647
23648 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23649 if test "x$test_cygdrive_prefix" = x; then
23650 # As a simple fix, exclude /usr/bin since it's not a real path.
23651 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23652 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23653 # a path prefixed by /cygdrive for fixpath to work.
23654 new_path="$CYGWIN_ROOT_PATH$input_path"
23655 fi
23656 fi
23657
23658
23659 if test "x$path" != "x$new_path"; then
23660 BOOT_JDK="$new_path"
23661 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23662 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23663 fi
23664
23665 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23666
23667 path="$BOOT_JDK"
23668 has_colon=`$ECHO $path | $GREP ^.:`
23669 new_path="$path"
23670 if test "x$has_colon" = x; then
23671 # Not in mixed or Windows style, start by that.
23672 new_path=`cmd //c echo $path`
23673 fi
23674
23675
23676 input_path="$new_path"
23677 # Check if we need to convert this using DOS-style short mode. If the path
23678 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23679 # take no chances and rewrite it.
23680 # Note: m4 eats our [], so we need to use [ and ] instead.
23681 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23682 if test "x$has_forbidden_chars" != x; then
23683 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23684 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23685 fi
23686
23687
23688 windows_path="$new_path"
23689 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23690 unix_path=`$CYGPATH -u "$windows_path"`
23691 new_path="$unix_path"
23692 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23693 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23694 new_path="$unix_path"
23695 fi
23696
23697 if test "x$path" != "x$new_path"; then
23698 BOOT_JDK="$new_path"
23699 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23700 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23701 fi
23702
23703 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23704 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23705
23706 else
23707 # We're on a unix platform. Hooray! :)
23708 path="$BOOT_JDK"
23709 has_space=`$ECHO "$path" | $GREP " "`
23710 if test "x$has_space" != x; then
23711 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23712 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23713 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23714 fi
23715
23716 # Use eval to expand a potential ~
23717 eval path="$path"
23718 if test ! -f "$path" && test ! -d "$path"; then
23719 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23720 fi
23721
23722 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23723 fi
23724 fi
23725
23726 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23727 $as_echo_n "checking for Boot JDK... " >&6; }
23728 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23729 $as_echo "$BOOT_JDK" >&6; }
23730 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23731 $as_echo_n "checking Boot JDK version... " >&6; }
23732 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23733 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23734 $as_echo "$BOOT_JDK_VERSION" >&6; }
23735 fi # end check jdk version
23736 fi # end check javac
23737 fi # end check java
23738 fi # end check boot jdk found
23739 fi
23740
23741 done
23742 fi
23743
23744 fi
23745
23746
23747 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23748 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23749 # Do we have a bin/java?
23750 if test ! -x "$BOOT_JDK/bin/java"; then
23751 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23752 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23753 BOOT_JDK_FOUND=no
23754 else
23755 # Do we have a bin/javac?
23756 if test ! -x "$BOOT_JDK/bin/javac"; then
23757 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23758 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23759 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23760 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23761 BOOT_JDK_FOUND=no
23762 else
23763 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23764 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23765
23766 # Extra M4 quote needed to protect [] in grep expression.
23767 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23768 if test "x$FOUND_CORRECT_VERSION" = x; then
23769 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23770 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23771 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23772 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23773 BOOT_JDK_FOUND=no
23774 else
23775 # We're done! :-)
23776 BOOT_JDK_FOUND=yes
23777
23778 # Only process if variable expands to non-empty
23779
23780 if test "x$BOOT_JDK" != x; then
23781 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23782
23783 # Input might be given as Windows format, start by converting to
23784 # unix format.
23785 path="$BOOT_JDK"
23786 new_path=`$CYGPATH -u "$path"`
23787
23788 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23789 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23790 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23791 # "foo.exe" is OK but "foo" is an error.
23792 #
23793 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23794 # It is also a way to make sure we got the proper file name for the real test later on.
23795 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23796 if test "x$test_shortpath" = x; then
23797 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23798 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23799 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23800 fi
23801
23802 # Call helper function which possibly converts this using DOS-style short mode.
23803 # If so, the updated path is stored in $new_path.
23804
23805 input_path="$new_path"
23806 # Check if we need to convert this using DOS-style short mode. If the path
23807 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23808 # take no chances and rewrite it.
23809 # Note: m4 eats our [], so we need to use [ and ] instead.
23810 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23811 if test "x$has_forbidden_chars" != x; then
23812 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23813 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23814 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23815 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23816 # Going to short mode and back again did indeed matter. Since short mode is
23817 # case insensitive, let's make it lowercase to improve readability.
23818 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23819 # Now convert it back to Unix-style (cygpath)
23820 input_path=`$CYGPATH -u "$shortmode_path"`
23821 new_path="$input_path"
23822 fi
23823 fi
23824
23825 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23826 if test "x$test_cygdrive_prefix" = x; then
23827 # As a simple fix, exclude /usr/bin since it's not a real path.
23828 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23829 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23830 # a path prefixed by /cygdrive for fixpath to work.
23831 new_path="$CYGWIN_ROOT_PATH$input_path"
23832 fi
23833 fi
23834
23835
23836 if test "x$path" != "x$new_path"; then
23837 BOOT_JDK="$new_path"
23838 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23839 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23840 fi
23841
23842 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23843
23844 path="$BOOT_JDK"
23845 has_colon=`$ECHO $path | $GREP ^.:`
23846 new_path="$path"
23847 if test "x$has_colon" = x; then
23848 # Not in mixed or Windows style, start by that.
23849 new_path=`cmd //c echo $path`
23850 fi
23851
23852
23853 input_path="$new_path"
23854 # Check if we need to convert this using DOS-style short mode. If the path
23855 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23856 # take no chances and rewrite it.
23857 # Note: m4 eats our [], so we need to use [ and ] instead.
23858 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23859 if test "x$has_forbidden_chars" != x; then
23860 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23861 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23862 fi
23863
23864
23865 windows_path="$new_path"
23866 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23867 unix_path=`$CYGPATH -u "$windows_path"`
23868 new_path="$unix_path"
23869 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23870 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23871 new_path="$unix_path"
23872 fi
23873
23874 if test "x$path" != "x$new_path"; then
23875 BOOT_JDK="$new_path"
23876 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23877 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23878 fi
23879
23880 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23881 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23882
23883 else
23884 # We're on a unix platform. Hooray! :)
23885 path="$BOOT_JDK"
23886 has_space=`$ECHO "$path" | $GREP " "`
23887 if test "x$has_space" != x; then
23888 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23889 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23890 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23891 fi
23892
23893 # Use eval to expand a potential ~
23894 eval path="$path"
23895 if test ! -f "$path" && test ! -d "$path"; then
23896 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23897 fi
23898
23899 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23900 fi
23901 fi
23902
23903 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23904 $as_echo_n "checking for Boot JDK... " >&6; }
23905 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23906 $as_echo "$BOOT_JDK" >&6; }
23907 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23908 $as_echo_n "checking Boot JDK version... " >&6; }
23909 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
23910 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23911 $as_echo "$BOOT_JDK_VERSION" >&6; }
23912 fi # end check jdk version
23913 fi # end check javac
23914 fi # end check java
23915 fi # end check boot jdk found
23916 fi
23917
23918
23919 if test "x$BOOT_JDK_FOUND" = xno; then
23920 # Now execute the test
23921
23922 if test "x$ProgramFiles" != x; then
23923 VIRTUAL_DIR="$ProgramFiles/Java"
23924
23925 windows_path="$VIRTUAL_DIR"
23926 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23927 unix_path=`$CYGPATH -u "$windows_path"`
23928 VIRTUAL_DIR="$unix_path"
23929 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23930 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23931 VIRTUAL_DIR="$unix_path"
23932 fi
23933
23934
23935 BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23936 BOOT_JDK_SUFFIX=""
23937 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23938 if test "x$ALL_JDKS_FOUND" != x; then
23939 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23940
23941 if test "x$BOOT_JDK_FOUND" = xno; then
23942 # Now execute the test
23943
23944 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23945 if test -d "$BOOT_JDK"; then
23946 BOOT_JDK_FOUND=maybe
23947 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23948 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23949 fi
23950
23951
23952 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23953 if test "x$BOOT_JDK_FOUND" = xmaybe; then
23954 # Do we have a bin/java?
23955 if test ! -x "$BOOT_JDK/bin/java"; then
23956 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23957 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23958 BOOT_JDK_FOUND=no
23959 else
23960 # Do we have a bin/javac?
23961 if test ! -x "$BOOT_JDK/bin/javac"; then
23962 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23963 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23964 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23965 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23966 BOOT_JDK_FOUND=no
23967 else
23968 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23969 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23970
23971 # Extra M4 quote needed to protect [] in grep expression.
23972 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
23973 if test "x$FOUND_CORRECT_VERSION" = x; then
23974 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23975 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23976 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23977 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23978 BOOT_JDK_FOUND=no
23979 else
23980 # We're done! :-)
23981 BOOT_JDK_FOUND=yes
23982
23983 # Only process if variable expands to non-empty
23984
23985 if test "x$BOOT_JDK" != x; then
23986 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23987
23988 # Input might be given as Windows format, start by converting to
23989 # unix format.
23990 path="$BOOT_JDK"
23991 new_path=`$CYGPATH -u "$path"`
23992
23993 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23994 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23995 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23996 # "foo.exe" is OK but "foo" is an error.
23997 #
23998 # This test is therefore slightly more accurate than "test -f" to check for file precense.
23999 # It is also a way to make sure we got the proper file name for the real test later on.
24000 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24001 if test "x$test_shortpath" = x; then
24002 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24003 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24004 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24005 fi
24006
24007 # Call helper function which possibly converts this using DOS-style short mode.
24008 # If so, the updated path is stored in $new_path.
24009
24010 input_path="$new_path"
24011 # Check if we need to convert this using DOS-style short mode. If the path
24012 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24013 # take no chances and rewrite it.
24014 # Note: m4 eats our [], so we need to use [ and ] instead.
24015 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24016 if test "x$has_forbidden_chars" != x; then
24017 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24018 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24019 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24020 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24021 # Going to short mode and back again did indeed matter. Since short mode is
24022 # case insensitive, let's make it lowercase to improve readability.
24023 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24024 # Now convert it back to Unix-style (cygpath)
24025 input_path=`$CYGPATH -u "$shortmode_path"`
24026 new_path="$input_path"
24027 fi
24028 fi
24029
24030 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24031 if test "x$test_cygdrive_prefix" = x; then
24032 # As a simple fix, exclude /usr/bin since it's not a real path.
24033 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24034 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24035 # a path prefixed by /cygdrive for fixpath to work.
24036 new_path="$CYGWIN_ROOT_PATH$input_path"
24037 fi
24038 fi
24039
24040
24041 if test "x$path" != "x$new_path"; then
24042 BOOT_JDK="$new_path"
24043 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24044 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24045 fi
24046
24047 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24048
24049 path="$BOOT_JDK"
24050 has_colon=`$ECHO $path | $GREP ^.:`
24051 new_path="$path"
24052 if test "x$has_colon" = x; then
24053 # Not in mixed or Windows style, start by that.
24054 new_path=`cmd //c echo $path`
24055 fi
24056
24057
24058 input_path="$new_path"
24059 # Check if we need to convert this using DOS-style short mode. If the path
24060 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24061 # take no chances and rewrite it.
24062 # Note: m4 eats our [], so we need to use [ and ] instead.
24063 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24064 if test "x$has_forbidden_chars" != x; then
24065 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24066 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24067 fi
24068
24069
24070 windows_path="$new_path"
24071 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24072 unix_path=`$CYGPATH -u "$windows_path"`
24073 new_path="$unix_path"
24074 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24075 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24076 new_path="$unix_path"
24077 fi
24078
24079 if test "x$path" != "x$new_path"; then
24080 BOOT_JDK="$new_path"
24081 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24082 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24083 fi
24084
24085 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24086 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24087
24088 else
24089 # We're on a unix platform. Hooray! :)
24090 path="$BOOT_JDK"
24091 has_space=`$ECHO "$path" | $GREP " "`
24092 if test "x$has_space" != x; then
24093 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24094 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24095 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24096 fi
24097
24098 # Use eval to expand a potential ~
24099 eval path="$path"
24100 if test ! -f "$path" && test ! -d "$path"; then
24101 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24102 fi
24103
24104 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24105 fi
24106 fi
24107
24108 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24109 $as_echo_n "checking for Boot JDK... " >&6; }
24110 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24111 $as_echo "$BOOT_JDK" >&6; }
24112 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24113 $as_echo_n "checking Boot JDK version... " >&6; }
24114 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24115 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24116 $as_echo "$BOOT_JDK_VERSION" >&6; }
24117 fi # end check jdk version
24118 fi # end check javac
24119 fi # end check java
24120 fi # end check boot jdk found
24121 fi
24122
24123 done
24124 fi
24125
24126 fi
24127
24128
24129 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24130 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24131 # Do we have a bin/java?
24132 if test ! -x "$BOOT_JDK/bin/java"; then
24133 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24134 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24135 BOOT_JDK_FOUND=no
24136 else
24137 # Do we have a bin/javac?
24138 if test ! -x "$BOOT_JDK/bin/javac"; then
24139 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24140 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24141 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24142 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24143 BOOT_JDK_FOUND=no
24144 else
24145 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24146 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24147
24148 # Extra M4 quote needed to protect [] in grep expression.
24149 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24150 if test "x$FOUND_CORRECT_VERSION" = x; then
24151 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24152 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24153 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24154 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24155 BOOT_JDK_FOUND=no
24156 else
24157 # We're done! :-)
24158 BOOT_JDK_FOUND=yes
24159
24160 # Only process if variable expands to non-empty
24161
24162 if test "x$BOOT_JDK" != x; then
24163 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24164
24165 # Input might be given as Windows format, start by converting to
24166 # unix format.
24167 path="$BOOT_JDK"
24168 new_path=`$CYGPATH -u "$path"`
24169
24170 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24171 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24172 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24173 # "foo.exe" is OK but "foo" is an error.
24174 #
24175 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24176 # It is also a way to make sure we got the proper file name for the real test later on.
24177 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24178 if test "x$test_shortpath" = x; then
24179 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24180 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24181 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24182 fi
24183
24184 # Call helper function which possibly converts this using DOS-style short mode.
24185 # If so, the updated path is stored in $new_path.
24186
24187 input_path="$new_path"
24188 # Check if we need to convert this using DOS-style short mode. If the path
24189 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24190 # take no chances and rewrite it.
24191 # Note: m4 eats our [], so we need to use [ and ] instead.
24192 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24193 if test "x$has_forbidden_chars" != x; then
24194 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24195 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24196 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24197 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24198 # Going to short mode and back again did indeed matter. Since short mode is
24199 # case insensitive, let's make it lowercase to improve readability.
24200 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24201 # Now convert it back to Unix-style (cygpath)
24202 input_path=`$CYGPATH -u "$shortmode_path"`
24203 new_path="$input_path"
24204 fi
24205 fi
24206
24207 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24208 if test "x$test_cygdrive_prefix" = x; then
24209 # As a simple fix, exclude /usr/bin since it's not a real path.
24210 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24211 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24212 # a path prefixed by /cygdrive for fixpath to work.
24213 new_path="$CYGWIN_ROOT_PATH$input_path"
24214 fi
24215 fi
24216
24217
24218 if test "x$path" != "x$new_path"; then
24219 BOOT_JDK="$new_path"
24220 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24221 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24222 fi
24223
24224 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24225
24226 path="$BOOT_JDK"
24227 has_colon=`$ECHO $path | $GREP ^.:`
24228 new_path="$path"
24229 if test "x$has_colon" = x; then
24230 # Not in mixed or Windows style, start by that.
24231 new_path=`cmd //c echo $path`
24232 fi
24233
24234
24235 input_path="$new_path"
24236 # Check if we need to convert this using DOS-style short mode. If the path
24237 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24238 # take no chances and rewrite it.
24239 # Note: m4 eats our [], so we need to use [ and ] instead.
24240 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24241 if test "x$has_forbidden_chars" != x; then
24242 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24243 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24244 fi
24245
24246
24247 windows_path="$new_path"
24248 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24249 unix_path=`$CYGPATH -u "$windows_path"`
24250 new_path="$unix_path"
24251 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24252 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24253 new_path="$unix_path"
24254 fi
24255
24256 if test "x$path" != "x$new_path"; then
24257 BOOT_JDK="$new_path"
24258 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24259 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24260 fi
24261
24262 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24263 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24264
24265 else
24266 # We're on a unix platform. Hooray! :)
24267 path="$BOOT_JDK"
24268 has_space=`$ECHO "$path" | $GREP " "`
24269 if test "x$has_space" != x; then
24270 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24271 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24272 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24273 fi
24274
24275 # Use eval to expand a potential ~
24276 eval path="$path"
24277 if test ! -f "$path" && test ! -d "$path"; then
24278 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24279 fi
24280
24281 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24282 fi
24283 fi
24284
24285 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24286 $as_echo_n "checking for Boot JDK... " >&6; }
24287 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24288 $as_echo "$BOOT_JDK" >&6; }
24289 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24290 $as_echo_n "checking Boot JDK version... " >&6; }
24291 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24292 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24293 $as_echo "$BOOT_JDK_VERSION" >&6; }
24294 fi # end check jdk version
24295 fi # end check javac
24296 fi # end check java
24297 fi # end check boot jdk found
24298 fi
24299
24300
24301 if test "x$BOOT_JDK_FOUND" = xno; then
24302 # Now execute the test
24303
24304 BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
24305 BOOT_JDK_SUFFIX=""
24306 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24307 if test "x$ALL_JDKS_FOUND" != x; then
24308 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24309
24310 if test "x$BOOT_JDK_FOUND" = xno; then
24311 # Now execute the test
24312
24313 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24314 if test -d "$BOOT_JDK"; then
24315 BOOT_JDK_FOUND=maybe
24316 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24317 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24318 fi
24319
24320
24321 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24322 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24323 # Do we have a bin/java?
24324 if test ! -x "$BOOT_JDK/bin/java"; then
24325 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24326 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24327 BOOT_JDK_FOUND=no
24328 else
24329 # Do we have a bin/javac?
24330 if test ! -x "$BOOT_JDK/bin/javac"; then
24331 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24332 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24333 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24334 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24335 BOOT_JDK_FOUND=no
24336 else
24337 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24338 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24339
24340 # Extra M4 quote needed to protect [] in grep expression.
24341 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24342 if test "x$FOUND_CORRECT_VERSION" = x; then
24343 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24344 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24345 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24346 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24347 BOOT_JDK_FOUND=no
24348 else
24349 # We're done! :-)
24350 BOOT_JDK_FOUND=yes
24351
24352 # Only process if variable expands to non-empty
24353
24354 if test "x$BOOT_JDK" != x; then
24355 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24356
24357 # Input might be given as Windows format, start by converting to
24358 # unix format.
24359 path="$BOOT_JDK"
24360 new_path=`$CYGPATH -u "$path"`
24361
24362 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24363 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24364 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24365 # "foo.exe" is OK but "foo" is an error.
24366 #
24367 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24368 # It is also a way to make sure we got the proper file name for the real test later on.
24369 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24370 if test "x$test_shortpath" = x; then
24371 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24372 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24373 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24374 fi
24375
24376 # Call helper function which possibly converts this using DOS-style short mode.
24377 # If so, the updated path is stored in $new_path.
24378
24379 input_path="$new_path"
24380 # Check if we need to convert this using DOS-style short mode. If the path
24381 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24382 # take no chances and rewrite it.
24383 # Note: m4 eats our [], so we need to use [ and ] instead.
24384 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24385 if test "x$has_forbidden_chars" != x; then
24386 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24387 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24388 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24389 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24390 # Going to short mode and back again did indeed matter. Since short mode is
24391 # case insensitive, let's make it lowercase to improve readability.
24392 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24393 # Now convert it back to Unix-style (cygpath)
24394 input_path=`$CYGPATH -u "$shortmode_path"`
24395 new_path="$input_path"
24396 fi
24397 fi
24398
24399 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24400 if test "x$test_cygdrive_prefix" = x; then
24401 # As a simple fix, exclude /usr/bin since it's not a real path.
24402 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24403 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24404 # a path prefixed by /cygdrive for fixpath to work.
24405 new_path="$CYGWIN_ROOT_PATH$input_path"
24406 fi
24407 fi
24408
24409
24410 if test "x$path" != "x$new_path"; then
24411 BOOT_JDK="$new_path"
24412 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24413 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24414 fi
24415
24416 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24417
24418 path="$BOOT_JDK"
24419 has_colon=`$ECHO $path | $GREP ^.:`
24420 new_path="$path"
24421 if test "x$has_colon" = x; then
24422 # Not in mixed or Windows style, start by that.
24423 new_path=`cmd //c echo $path`
24424 fi
24425
24426
24427 input_path="$new_path"
24428 # Check if we need to convert this using DOS-style short mode. If the path
24429 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24430 # take no chances and rewrite it.
24431 # Note: m4 eats our [], so we need to use [ and ] instead.
24432 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24433 if test "x$has_forbidden_chars" != x; then
24434 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24435 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24436 fi
24437
24438
24439 windows_path="$new_path"
24440 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24441 unix_path=`$CYGPATH -u "$windows_path"`
24442 new_path="$unix_path"
24443 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24444 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24445 new_path="$unix_path"
24446 fi
24447
24448 if test "x$path" != "x$new_path"; then
24449 BOOT_JDK="$new_path"
24450 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24451 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24452 fi
24453
24454 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24455 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24456
24457 else
24458 # We're on a unix platform. Hooray! :)
24459 path="$BOOT_JDK"
24460 has_space=`$ECHO "$path" | $GREP " "`
24461 if test "x$has_space" != x; then
24462 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24463 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24464 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24465 fi
24466
24467 # Use eval to expand a potential ~
24468 eval path="$path"
24469 if test ! -f "$path" && test ! -d "$path"; then
24470 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24471 fi
24472
24473 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24474 fi
24475 fi
24476
24477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24478 $as_echo_n "checking for Boot JDK... " >&6; }
24479 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24480 $as_echo "$BOOT_JDK" >&6; }
24481 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24482 $as_echo_n "checking Boot JDK version... " >&6; }
24483 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24484 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24485 $as_echo "$BOOT_JDK_VERSION" >&6; }
24486 fi # end check jdk version
24487 fi # end check javac
24488 fi # end check java
24489 fi # end check boot jdk found
24490 fi
24491
24492 done
24493 fi
24494
24495
24496 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24497 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24498 # Do we have a bin/java?
24499 if test ! -x "$BOOT_JDK/bin/java"; then
24500 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24501 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24502 BOOT_JDK_FOUND=no
24503 else
24504 # Do we have a bin/javac?
24505 if test ! -x "$BOOT_JDK/bin/javac"; then
24506 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24507 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24508 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24509 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24510 BOOT_JDK_FOUND=no
24511 else
24512 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24513 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24514
24515 # Extra M4 quote needed to protect [] in grep expression.
24516 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24517 if test "x$FOUND_CORRECT_VERSION" = x; then
24518 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24519 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24520 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24521 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24522 BOOT_JDK_FOUND=no
24523 else
24524 # We're done! :-)
24525 BOOT_JDK_FOUND=yes
24526
24527 # Only process if variable expands to non-empty
24528
24529 if test "x$BOOT_JDK" != x; then
24530 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24531
24532 # Input might be given as Windows format, start by converting to
24533 # unix format.
24534 path="$BOOT_JDK"
24535 new_path=`$CYGPATH -u "$path"`
24536
24537 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24538 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24539 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24540 # "foo.exe" is OK but "foo" is an error.
24541 #
24542 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24543 # It is also a way to make sure we got the proper file name for the real test later on.
24544 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24545 if test "x$test_shortpath" = x; then
24546 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24547 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24548 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24549 fi
24550
24551 # Call helper function which possibly converts this using DOS-style short mode.
24552 # If so, the updated path is stored in $new_path.
24553
24554 input_path="$new_path"
24555 # Check if we need to convert this using DOS-style short mode. If the path
24556 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24557 # take no chances and rewrite it.
24558 # Note: m4 eats our [], so we need to use [ and ] instead.
24559 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24560 if test "x$has_forbidden_chars" != x; then
24561 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24562 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24563 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24564 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24565 # Going to short mode and back again did indeed matter. Since short mode is
24566 # case insensitive, let's make it lowercase to improve readability.
24567 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24568 # Now convert it back to Unix-style (cygpath)
24569 input_path=`$CYGPATH -u "$shortmode_path"`
24570 new_path="$input_path"
24571 fi
24572 fi
24573
24574 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24575 if test "x$test_cygdrive_prefix" = x; then
24576 # As a simple fix, exclude /usr/bin since it's not a real path.
24577 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24578 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24579 # a path prefixed by /cygdrive for fixpath to work.
24580 new_path="$CYGWIN_ROOT_PATH$input_path"
24581 fi
24582 fi
24583
24584
24585 if test "x$path" != "x$new_path"; then
24586 BOOT_JDK="$new_path"
24587 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24588 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24589 fi
24590
24591 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24592
24593 path="$BOOT_JDK"
24594 has_colon=`$ECHO $path | $GREP ^.:`
24595 new_path="$path"
24596 if test "x$has_colon" = x; then
24597 # Not in mixed or Windows style, start by that.
24598 new_path=`cmd //c echo $path`
24599 fi
24600
24601
24602 input_path="$new_path"
24603 # Check if we need to convert this using DOS-style short mode. If the path
24604 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24605 # take no chances and rewrite it.
24606 # Note: m4 eats our [], so we need to use [ and ] instead.
24607 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24608 if test "x$has_forbidden_chars" != x; then
24609 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24610 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24611 fi
24612
24613
24614 windows_path="$new_path"
24615 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24616 unix_path=`$CYGPATH -u "$windows_path"`
24617 new_path="$unix_path"
24618 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24619 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24620 new_path="$unix_path"
24621 fi
24622
24623 if test "x$path" != "x$new_path"; then
24624 BOOT_JDK="$new_path"
24625 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24626 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24627 fi
24628
24629 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24630 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24631
24632 else
24633 # We're on a unix platform. Hooray! :)
24634 path="$BOOT_JDK"
24635 has_space=`$ECHO "$path" | $GREP " "`
24636 if test "x$has_space" != x; then
24637 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24638 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24639 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24640 fi
24641
24642 # Use eval to expand a potential ~
24643 eval path="$path"
24644 if test ! -f "$path" && test ! -d "$path"; then
24645 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24646 fi
24647
24648 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24649 fi
24650 fi
24651
24652 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24653 $as_echo_n "checking for Boot JDK... " >&6; }
24654 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24655 $as_echo "$BOOT_JDK" >&6; }
24656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24657 $as_echo_n "checking Boot JDK version... " >&6; }
24658 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24659 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24660 $as_echo "$BOOT_JDK_VERSION" >&6; }
24661 fi # end check jdk version
24662 fi # end check javac
24663 fi # end check java
24664 fi # end check boot jdk found
24665 fi
24666
24667 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
24668
24669 if test "x$BOOT_JDK_FOUND" = xno; then
24670 # Now execute the test
24671
24672 BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
24673 BOOT_JDK_SUFFIX="/Contents/Home"
24674 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24675 if test "x$ALL_JDKS_FOUND" != x; then
24676 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24677
24678 if test "x$BOOT_JDK_FOUND" = xno; then
24679 # Now execute the test
24680
24681 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24682 if test -d "$BOOT_JDK"; then
24683 BOOT_JDK_FOUND=maybe
24684 { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24685 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24686 fi
24687
24688
24689 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24690 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24691 # Do we have a bin/java?
24692 if test ! -x "$BOOT_JDK/bin/java"; then
24693 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24694 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24695 BOOT_JDK_FOUND=no
24696 else
24697 # Do we have a bin/javac?
24698 if test ! -x "$BOOT_JDK/bin/javac"; then
24699 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24700 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24701 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24702 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24703 BOOT_JDK_FOUND=no
24704 else
24705 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24706 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24707
24708 # Extra M4 quote needed to protect [] in grep expression.
24709 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24710 if test "x$FOUND_CORRECT_VERSION" = x; then
24711 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24712 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24713 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24714 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24715 BOOT_JDK_FOUND=no
24716 else
24717 # We're done! :-)
24718 BOOT_JDK_FOUND=yes
24719
24720 # Only process if variable expands to non-empty
24721
24722 if test "x$BOOT_JDK" != x; then
24723 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24724
24725 # Input might be given as Windows format, start by converting to
24726 # unix format.
24727 path="$BOOT_JDK"
24728 new_path=`$CYGPATH -u "$path"`
24729
24730 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24731 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24732 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24733 # "foo.exe" is OK but "foo" is an error.
24734 #
24735 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24736 # It is also a way to make sure we got the proper file name for the real test later on.
24737 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24738 if test "x$test_shortpath" = x; then
24739 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24740 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24741 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24742 fi
24743
24744 # Call helper function which possibly converts this using DOS-style short mode.
24745 # If so, the updated path is stored in $new_path.
24746
24747 input_path="$new_path"
24748 # Check if we need to convert this using DOS-style short mode. If the path
24749 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24750 # take no chances and rewrite it.
24751 # Note: m4 eats our [], so we need to use [ and ] instead.
24752 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24753 if test "x$has_forbidden_chars" != x; then
24754 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24755 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24756 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24757 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24758 # Going to short mode and back again did indeed matter. Since short mode is
24759 # case insensitive, let's make it lowercase to improve readability.
24760 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24761 # Now convert it back to Unix-style (cygpath)
24762 input_path=`$CYGPATH -u "$shortmode_path"`
24763 new_path="$input_path"
24764 fi
24765 fi
24766
24767 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24768 if test "x$test_cygdrive_prefix" = x; then
24769 # As a simple fix, exclude /usr/bin since it's not a real path.
24770 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24771 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24772 # a path prefixed by /cygdrive for fixpath to work.
24773 new_path="$CYGWIN_ROOT_PATH$input_path"
24774 fi
24775 fi
24776
24777
24778 if test "x$path" != "x$new_path"; then
24779 BOOT_JDK="$new_path"
24780 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24781 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24782 fi
24783
24784 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24785
24786 path="$BOOT_JDK"
24787 has_colon=`$ECHO $path | $GREP ^.:`
24788 new_path="$path"
24789 if test "x$has_colon" = x; then
24790 # Not in mixed or Windows style, start by that.
24791 new_path=`cmd //c echo $path`
24792 fi
24793
24794
24795 input_path="$new_path"
24796 # Check if we need to convert this using DOS-style short mode. If the path
24797 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24798 # take no chances and rewrite it.
24799 # Note: m4 eats our [], so we need to use [ and ] instead.
24800 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24801 if test "x$has_forbidden_chars" != x; then
24802 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24803 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24804 fi
24805
24806
24807 windows_path="$new_path"
24808 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24809 unix_path=`$CYGPATH -u "$windows_path"`
24810 new_path="$unix_path"
24811 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24812 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24813 new_path="$unix_path"
24814 fi
24815
24816 if test "x$path" != "x$new_path"; then
24817 BOOT_JDK="$new_path"
24818 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24819 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24820 fi
24821
24822 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24823 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24824
24825 else
24826 # We're on a unix platform. Hooray! :)
24827 path="$BOOT_JDK"
24828 has_space=`$ECHO "$path" | $GREP " "`
24829 if test "x$has_space" != x; then
24830 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24831 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24832 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24833 fi
24834
24835 # Use eval to expand a potential ~
24836 eval path="$path"
24837 if test ! -f "$path" && test ! -d "$path"; then
24838 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24839 fi
24840
24841 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24842 fi
24843 fi
24844
24845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24846 $as_echo_n "checking for Boot JDK... " >&6; }
24847 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24848 $as_echo "$BOOT_JDK" >&6; }
24849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24850 $as_echo_n "checking Boot JDK version... " >&6; }
24851 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
24852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24853 $as_echo "$BOOT_JDK_VERSION" >&6; }
24854 fi # end check jdk version
24855 fi # end check javac
24856 fi # end check java
24857 fi # end check boot jdk found
24858 fi
24859
24860 done
24861 fi
24862
24863
24864 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24865 if test "x$BOOT_JDK_FOUND" = xmaybe; then
24866 # Do we have a bin/java?
24867 if test ! -x "$BOOT_JDK/bin/java"; then
24868 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24869 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24870 BOOT_JDK_FOUND=no
24871 else
24872 # Do we have a bin/javac?
24873 if test ! -x "$BOOT_JDK/bin/javac"; then
24874 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24875 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24876 { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24877 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24878 BOOT_JDK_FOUND=no
24879 else
24880 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24881 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24882
24883 # Extra M4 quote needed to protect [] in grep expression.
24884 FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep '\"1\.[89]\.'`
24885 if test "x$FOUND_CORRECT_VERSION" = x; then
24886 { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24887 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24888 { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24889 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24890 BOOT_JDK_FOUND=no
24891 else
24892 # We're done! :-)
24893 BOOT_JDK_FOUND=yes
24894
24895 # Only process if variable expands to non-empty
24896
24897 if test "x$BOOT_JDK" != x; then
24898 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24899
24900 # Input might be given as Windows format, start by converting to
24901 # unix format.
24902 path="$BOOT_JDK"
24903 new_path=`$CYGPATH -u "$path"`
24904
24905 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24906 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24907 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24908 # "foo.exe" is OK but "foo" is an error.
24909 #
24910 # This test is therefore slightly more accurate than "test -f" to check for file precense.
24911 # It is also a way to make sure we got the proper file name for the real test later on.
24912 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24913 if test "x$test_shortpath" = x; then
24914 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24915 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24916 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24917 fi
24918
24919 # Call helper function which possibly converts this using DOS-style short mode.
24920 # If so, the updated path is stored in $new_path.
24921
24922 input_path="$new_path"
24923 # Check if we need to convert this using DOS-style short mode. If the path
24924 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24925 # take no chances and rewrite it.
24926 # Note: m4 eats our [], so we need to use [ and ] instead.
24927 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24928 if test "x$has_forbidden_chars" != x; then
24929 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24930 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24931 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24932 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24933 # Going to short mode and back again did indeed matter. Since short mode is
24934 # case insensitive, let's make it lowercase to improve readability.
24935 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24936 # Now convert it back to Unix-style (cygpath)
24937 input_path=`$CYGPATH -u "$shortmode_path"`
24938 new_path="$input_path"
24939 fi
24940 fi
24941
24942 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24943 if test "x$test_cygdrive_prefix" = x; then
24944 # As a simple fix, exclude /usr/bin since it's not a real path.
24945 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24946 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24947 # a path prefixed by /cygdrive for fixpath to work.
24948 new_path="$CYGWIN_ROOT_PATH$input_path"
24949 fi
24950 fi
24951
24952
24953 if test "x$path" != "x$new_path"; then
24954 BOOT_JDK="$new_path"
24955 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24956 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24957 fi
24958
24959 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24960
24961 path="$BOOT_JDK"
24962 has_colon=`$ECHO $path | $GREP ^.:`
24963 new_path="$path"
24964 if test "x$has_colon" = x; then
24965 # Not in mixed or Windows style, start by that.
24966 new_path=`cmd //c echo $path`
24967 fi
24968
24969
24970 input_path="$new_path"
24971 # Check if we need to convert this using DOS-style short mode. If the path
24972 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24973 # take no chances and rewrite it.
24974 # Note: m4 eats our [], so we need to use [ and ] instead.
24975 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24976 if test "x$has_forbidden_chars" != x; then
24977 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24978 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24979 fi
24980
24981
24982 windows_path="$new_path"
24983 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24984 unix_path=`$CYGPATH -u "$windows_path"`
24985 new_path="$unix_path"
24986 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24987 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24988 new_path="$unix_path"
24989 fi
24990
24991 if test "x$path" != "x$new_path"; then
24992 BOOT_JDK="$new_path"
24993 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24994 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24995 fi
24996
24997 # Save the first 10 byte